Bagaimana cara keluar dari loop dari dalam sebuah saklar?

Saya menulis beberapa kode yang terlihat seperti ini:

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        break; // **HERE, I want to break out of the loop itself**
    }
}

Apakah ada cara langsung untuk melakukan itu?

Saya tahu saya bisa menggunakan sebuah bendera, dan keluar dari perulangan dengan meletakkan jeda bersyarat tepat setelah saklar. Saya hanya ingin tahu apakah C ++ sudah memiliki beberapa konstruksi untuk ini.

Premis

Kode berikut harus dianggap bentuk yang buruk, terlepas dari bahasa atau fungsi yang diinginkan:

while( true ) {
}

Argumen Pendukung

Bentuk while( true )loopnya buruk karena:

• Memutus kontrak tersirat dari loop sementara.
  • Deklarasi while loop harus secara eksplisit menyatakan satu - satunya kondisi keluar.
• Menyiratkan bahwa loop selamanya.
  • Kode di dalam loop harus dibaca untuk memahami klausa terminating.
  • Loop yang berulang selamanya mencegah pengguna untuk menghentikan program dari dalam program.
• Tidak efisien.
  • Ada beberapa kondisi penghentian loop, termasuk memeriksa "benar".
• Rawan bug.
  • Tidak dapat dengan mudah menentukan di mana harus meletakkan kode yang akan selalu dieksekusi untuk setiap iterasi.
• Menghasilkan kode kompleks yang tidak perlu.
• Analisis kode sumber otomatis.
  • Untuk menemukan bug, analisis kompleksitas program, pemeriksaan keamanan, atau secara otomatis mendapatkan perilaku kode sumber lainnya tanpa eksekusi kode, menentukan kondisi pemutusan awal memungkinkan algoritme untuk menentukan invarian yang berguna, sehingga meningkatkan metrik analisis kode sumber otomatis.
• Loop tak terbatas.
  • Jika setiap orang selalu menggunakan while(true)untuk loop yang tidak terbatas, kita kehilangan kemampuan untuk berkomunikasi secara ringkas ketika loop sebenarnya tidak memiliki kondisi penghentian. (Bisa dibilang, ini sudah terjadi, jadi intinya diperdebatkan.)

Alternatif untuk "Pergi ke"

Kode berikut adalah bentuk yang lebih baik:

while( isValidState() ) {
  execute();
}

bool isValidState() {
  return msg->state != DONE;
}

Keuntungan

Tidak ada bendera. Tidak goto. Tanpa pengecualian. Mudah diubah. Mudah dibaca. Mudah diperbaiki. Selain itu kode:

1. Mengisolasi pengetahuan tentang beban kerja loop dari loop itu sendiri.
2. Memungkinkan seseorang memelihara kode dengan mudah memperluas fungsinya.
3. Memungkinkan beberapa kondisi pengakhiran untuk ditugaskan di satu tempat.
4. Memisahkan klausa penghentian dari kode yang akan dieksekusi.
5. Lebih aman untuk pembangkit listrik tenaga nuklir. ;-)

Poin kedua penting. Tanpa mengetahui cara kerja kode, jika seseorang meminta saya untuk membuat loop utama, biarkan utas (atau proses) lain memiliki waktu CPU, dua solusi muncul dalam pikiran:

Pilihan 1

Masukkan jeda dengan mudah:

while( isValidState() ) {
  execute();
  sleep();
}

Pilihan 2

Timpa eksekusi:

void execute() {
  super->execute();
  sleep();
}

Kode ini lebih sederhana (sehingga lebih mudah dibaca) daripada loop dengan embedded switch. The isValidStateMetode hanya harus menentukan apakah loop harus terus. Pekerja keras metode ini harus diabstraksikan ke dalam executemetode, yang memungkinkan subclass untuk menimpa perilaku default (tugas yang sulit menggunakan switchdan tertanam goto).

Contoh Python

Bandingkan jawaban berikut (dengan pertanyaan Python) yang diposting di StackOverflow:

1. Ulangi selamanya.
2. Minta pengguna untuk memasukkan pilihan mereka.
3. Jika input pengguna adalah 'restart', lanjutkan looping selamanya.
4. Jika tidak, hentikan perulangan selamanya.
5. Akhir.

while True: 
    choice = raw_input('What do you want? ')

    if choice == 'restart':
        continue
    else:
        break

print 'Break!' 

Melawan:

1. Inisialisasi pilihan pengguna.
2. Loop sedangkan pilihan pengguna adalah kata 'restart'.
3. Minta pengguna untuk memasukkan pilihan mereka.
4. Akhir.

choice = 'restart';

while choice == 'restart': 
    choice = raw_input('What do you want? ')

print 'Break!'

Di sini, while Truemenghasilkan kode yang menyesatkan dan terlalu kompleks.

Anda bisa menggunakan goto.

while ( ... ) {
   switch( ... ) {
     case ...:
         goto exit_loop;

   }
}
exit_loop: ;

Solusi alternatifnya adalah dengan menggunakan kata kunci continuedalam kombinasi dengan break, yaitu:

for (;;) {
    switch(msg->state) {
    case MSGTYPE
        // code
        continue; // continue with loop
    case DONE:
        break;
    }
    break;
}

Gunakan continuepernyataan untuk menyelesaikan setiap label kasus di mana Anda ingin pengulangan melanjutkan dan gunakan breakpernyataan untuk menyelesaikan label kasus yang harus menghentikan pengulangan.

Tentu saja solusi ini hanya berfungsi jika tidak ada kode tambahan untuk dieksekusi setelah pernyataan switch.

Cara yang rapi untuk melakukan ini adalah dengan memasukkan ini ke dalam sebuah fungsi:

int yourfunc() {

    while(true) {

        switch(msg->state) {
        case MSGTYPE: // ... 
            break;
        // ... more stuff ...
        case DONE:
            return; 
        }

    }
}

Opsional (tapi 'praktik buruk'): seperti yang sudah disarankan, Anda bisa menggunakan goto, atau melempar pengecualian di dalam sakelar.

AFAIK tidak ada "istirahat ganda" atau konstruksi serupa di C ++. Yang paling dekat adalah a goto- yang, meskipun memiliki konotasi buruk untuk namanya, ada dalam bahasa karena suatu alasan - selama digunakan dengan hati-hati dan hemat, itu adalah opsi yang layak.

Anda dapat meletakkan sakelar Anda ke fungsi terpisah seperti ini:

bool myswitchfunction()
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        return false; // **HERE, I want to break out of the loop itself**
    }
    return true;
}

while(myswitchfunction())
    ;

Bahkan jika Anda tidak suka goto, jangan gunakan pengecualian untuk keluar dari loop. Contoh berikut menunjukkan betapa jeleknya itu:

try {
  while ( ... ) {
    switch( ... ) {
      case ...:
        throw 777; // I'm afraid of goto
     }
  }
}
catch ( int )
{
}

Saya akan menggunakan gotoseperti dalam jawaban ini . Dalam hal ini gotoakan membuat kode lebih jelas daripada opsi lainnya. Saya berharap bahwa ini pertanyaan akan membantu.

Tapi saya pikir menggunakan gotoadalah satu-satunya pilihan di sini karena stringnya while(true). Anda harus mempertimbangkan refactoring loop Anda. Saya kira solusi berikut:

bool end_loop = false;
while ( !end_loop ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        end_loop = true; break;
    }
}

Atau bahkan yang berikut ini:

while ( msg->state != DONE ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
}

Tidak ada konstruksi C ++ untuk mendobrak loop dalam kasus ini.

Gunakan flag untuk menghentikan loop atau (jika sesuai) ekstrak kode Anda ke dalam fungsi dan gunakan return.

Anda berpotensi menggunakan goto, tetapi saya lebih suka menyetel bendera yang menghentikan pengulangan. Kemudian keluar dari sakelar.

Mengapa tidak memperbaiki kondisi di while loop Anda, menyebabkan masalah hilang?

while(msg->state != DONE)
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        // We can't get here, but for completeness we list it.
        break; // **HERE, I want to break out of the loop itself**
    }
}

Tidak, C ++ tidak memiliki konstruksi untuk ini, mengingat kata kunci "break" sudah disediakan untuk keluar dari blok switch. Alternatifnya, do.. while () dengan flag exit sudah cukup.

do { 
    switch(option){
        case 1: ..; break;
        ...
        case n: .. ;break;
        default: flag = false; break;
    }
} while(flag);

Kupikir;

while(msg->state != mExit) 
{
    switch(msg->state) 
    {
      case MSGTYPE: // ...
         break;
      case DONE:
      //  .. 
      //  ..
      msg->state =mExit;
      break;
    }
}
if (msg->state ==mExit)
     msg->state =DONE;

Cara termudah untuk melakukannya adalah dengan meletakkan IF sederhana sebelum Anda melakukan SWITCH, dan IF menguji kondisi Anda untuk keluar dari loop ......... sesederhana mungkin

Kata breakkunci dalam C ++ hanya mengakhiri iterasi atau switchpernyataan yang paling bertingkat . Jadi, Anda tidak bisa keluar dari while (true)loop langsung di dalam switchpernyataan; namun Anda dapat menggunakan kode berikut, yang menurut saya merupakan pola yang sangat baik untuk jenis masalah ini:

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

Jika Anda perlu melakukan sesuatu saat msg->statesama DONE(seperti menjalankan rutinitas pembersihan), letakkan kode tersebut segera setelah forpengulangan; yaitu jika saat ini Anda memiliki:

while (true) {
    switch (msg->state) {
    case MSGTYPE:
        //... 
        break;

    //...

    case DONE:
        do_cleanup();
        break;
    }

    if (msg->state == DONE)
        break;

    msg = next_message();
}

Kemudian gunakan sebagai gantinya:

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

assert(msg->state == DONE);
do_cleanup();

Sungguh mengherankan saya betapa sederhananya ini mengingat kedalaman penjelasan ... Inilah yang Anda butuhkan ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL !! Betulkah! Hanya itu yang Anda butuhkan! Satu variabel ekstra!

while(MyCondition) {
switch(msg->state) {
case MSGTYPE: // ... 
    break;
// ... more stuff ...
case DONE:
   MyCondition=false; // just add this code and you will be out of loop.
    break; // **HERE, you want to break out of the loop itself**
}
}

Saya mendapat masalah yang sama dan diselesaikan dengan menggunakan bendera.

bool flag = false;
while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        flag = true; // **HERE, I want to break out of the loop itself**
    }
    if(flag) break;
}

Jika saya mengingat sintaks C ++ dengan baik, Anda dapat menambahkan label ke breakpernyataan, seperti untuk goto. Jadi apa yang Anda inginkan akan mudah ditulis:

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ...
        break;
    // ... more stuff ...
    case DONE:
        break outofloop; // **HERE, I want to break out of the loop itself**
    }
}

outofloop:
// rest of your code here

  while(true)
  {
    switch(x)
    {
     case 1:
     {
      break;
     }
    break;
   case 2:
    //some code here
   break;
  default:
  //some code here
  }
}