Bir anahtarın içinden bir döngüden nasıl çıkılır?

Şuna benzeyen bir kod yazıyorum:

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

Bunu yapmanın doğrudan bir yolu var mı?

Bir bayrak kullanabileceğimi ve anahtardan hemen sonra koşullu bir mola vererek döngüden kopabileceğimi biliyorum. Sadece C ++ 'nın bunun için bir yapıya sahip olup olmadığını bilmek istiyorum.

Öncül

Aşağıdaki kod, dil veya istenen işlevsellikten bağımsız olarak kötü form olarak kabul edilmelidir:

while( true ) {
}

Destekleyici Argümanlar

while( true )Döngü bunun nedeni kötü biçimidir:

• Bir while döngüsünün zımni sözleşmesini bozar.
  • While döngüsü bildirimi, tek çıkış koşulunu açıkça belirtmelidir .
• Sonsuza dek döndüğünü ima eder.
  • Sonlandırma cümlesini anlamak için döngü içindeki kod okunmalıdır.
  • Sonsuza kadar tekrar eden döngüler, kullanıcının programı program içinden sonlandırmasını engeller.
• Verimsizdir.
  • "Doğru" nun kontrol edilmesi dahil olmak üzere birden fazla döngü sonlandırma koşulu vardır.
• Böceklere eğilimlidir.
  • Her yineleme için her zaman çalıştırılacak kodun nereye koyulacağını kolayca belirleyemez.
• Gereksiz karmaşık koda yol açar.
• Otomatik kaynak kodu analizi.
  • Hataları bulmak, program karmaşıklığı analizi, güvenlik kontrolleri yapmak veya kod yürütmeden başka herhangi bir kaynak kodu davranışını otomatik olarak türetmek için, ilk kırılma koşullarının belirtilmesi, algoritmaların yararlı değişmezleri belirlemesine olanak tanır ve böylece otomatik kaynak kodu analizi ölçümlerini iyileştirir.
• Sonsuz döngüler.
  • Herkes while(true)sonsuz olmayan döngüler için her zaman kullanıyorsa , döngüler gerçekte sonlandırma koşulu olmadığında kısaca iletişim kurma yeteneğimizi kaybederiz. (Muhtemelen, bu zaten olmuştur, bu nedenle mesele tartışmalıdır.)

"Git" e alternatif

Aşağıdaki kod daha iyi bir formdur:

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

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

Avantajları

Bayrak yok. Hayır goto. İstisna yok. Değiştirmesi kolay. Okuması kolay. Düzeltmesi kolay. Ek olarak kod:

1. Döngünün iş yükü bilgisini döngünün kendisinden ayırır.
2. Kodu koruyan birinin işlevselliği kolayca genişletmesine izin verir.
3. Tek bir yerde birden çok sonlandırma koşulunun atanmasına izin verir.
4. Yürütülecek koddan sonlandırma cümlesini ayırır.
5. Nükleer Santraller için daha güvenlidir. ;-)

İkinci nokta önemlidir. Kodun nasıl çalıştığını bilmeden, birisi benden ana döngüyü yapmamı isterse, diğer iş parçacıklarının (veya işlemlerin) biraz CPU zamanı olmasına izin vermesi durumunda, akla iki çözüm gelir:

Seçenek 1

Duraklamayı kolayca ekleyin:

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

Seçenek 2

Yürütmeyi geçersiz kıl:

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

Bu kod, gömülü bir döngüden daha basittir (dolayısıyla okunması daha kolaydır) switch. isValidStateDöngü sürdürmesi konusunda yöntem yalnızca belirlemelidir. Yöntemin iş gücü, executealt sınıfların varsayılan davranışı geçersiz kılmasına izin veren yönteme soyutlanmalıdır (gömülü switchve kullanan zor bir görev goto).

Python Örneği

StackOverflow'da yayınlanan aşağıdaki yanıtı (bir Python sorusuyla) karşılaştırın:

1. Sonsuza kadar döngü.
2. Kullanıcıdan seçimini girmesini isteyin.
3. Kullanıcının girdisi 'yeniden başlat' ise sonsuza kadar döngüye devam edin.
4. Aksi takdirde, döngüyü sonsuza kadar durdurun.
5. Son.

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

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

print 'Break!' 

Karşı:

1. Kullanıcının seçimini başlatın.
2. Kullanıcının seçimi 'yeniden başlatma' iken döngü.
3. Kullanıcıdan seçimini girmesini isteyin.
4. Son.

choice = 'restart';

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

print 'Break!'

Burada while Trueyanıltıcı ve aşırı karmaşık kodlar ortaya çıkar.

Kullanabilirsiniz goto.

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

   }
}
exit_loop: ;

Alternatif bir çözüm, anahtar kelimeyi aşağıdakilerle continuekombinasyon halinde kullanmaktır break, yani:

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

continueDöngünün devam etmesini istediğiniz her durum etiketini bitirmek için deyimi kullanın ve döngüyü breaksonlandırması gereken büyük / küçük harf etiketlerini bitirmek için deyimi kullanın.

Elbette bu çözüm yalnızca switch ifadesinden sonra yürütülecek ek kod yoksa işe yarar.

Bunu yapmanın düzgün bir yolu, bunu bir işleve sokmak olabilir:

int yourfunc() {

    while(true) {

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

    }
}

İsteğe bağlı olarak (ancak 'kötü uygulamalar'): daha önce önerildiği gibi, bir goto kullanabilir veya anahtarın içine bir istisna atabilirsiniz.

AFAIK, C ++ 'da "çift kesme" veya benzeri bir yapı yoktur. En yakın olanı goto- ismine kötü bir çağrışım olsa da, dilde bir sebepten dolayı var olan - dikkatli ve idareli kullanıldığı sürece geçerli bir seçenek olacaktır.

Anahtarınızı aşağıdaki gibi ayrı bir işleve koyabilirsiniz:

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())
    ;

Gitmeyi sevmeseniz bile, döngüden çıkmak için bir istisna kullanmayın. Aşağıdaki örnek bunun ne kadar çirkin olabileceğini göstermektedir:

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

Bu cevapta gotoolduğu gibi kullanırdım . Bu durumda , kodu diğer seçeneklerden daha net hale getirecektir. Umarım bu soru yardımcı olur.goto

Ama bence gotodizeden dolayı buradaki tek seçenek kullanmak while(true). Döngünüzü yeniden düzenlemeyi düşünmelisiniz. Sanırım aşağıdaki çözüm:

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

Ya da aşağıdakileri bile:

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

Bu durumda döngüden çıkmak için C ++ yapısı yoktur.

Döngüyü kesmek için bir bayrak kullanın veya (uygunsa) kodunuzu bir işleve çıkarın ve kullanın return.

Potansiyel olarak goto kullanabilirsiniz, ancak döngüyü durduran bir bayrak ayarlamayı tercih ederim. Sonra anahtardan çıkın.

Neden sadece while döngünüzdeki koşulu düzeltip sorunun ortadan kalkmasına neden olmuyorsunuz?

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**
    }
}

Hayır, "break" anahtar sözcüğü zaten anahtar bloğundan çıkmak için ayrılmış olduğundan, C ++ bunun için bir yapıya sahip değildir. Alternatif olarak, çıkış bayrağına sahip bir do.. while () yeterli olabilir.

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

Bence;

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

Bunu yapmanın en basit yolu, ANAHTARı yapmadan önce basit bir EĞER koymak ve bu EĞER döngüden çıkmak için koşulunuzu test etmektir .......... olabildiğince basit

breakC ++ anahtar kelime sadece en iç içe kapsayan yineleme veya sonlandırır switchdeyimi. Böylece,while (true) doğrudan ifade içinde döngüden switchçıkamazsınız; bununla birlikte, bu tür problemler için mükemmel bir model olduğunu düşündüğüm aşağıdaki kodu kullanabilirsiniz:

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

    //...
    }
}

msg->stateEşit olduğunda bir şey yapmanız gerekiyorsaDONE (temizleme rutini çalıştırmak gibi), o kodu fordöngüden hemen sonra yerleştirin ; yani şu anda sahipseniz:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

O zaman bunun yerine şunu kullanın:

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

    //...
    }
}

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

Açıklamaların derinliği düşünüldüğünde bunun ne kadar basit olması beni şaşırtıyor ... İşte ihtiyacınız olan her şey ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL !! Gerçekten mi! Tek ihtiyacın olan bu! Ekstra bir değişken!

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**
}
}

Aynı sorunu yaşadım ve bir bayrak kullanarak çözdüm.

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;
}

C ++ sözdizimini iyi hatırlıyorsam break, için olduğu gibi ifadelere bir etiket ekleyebilirsiniz goto. Yani istediğiniz şey kolayca yazılabilir:

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
  }
}