Jak wyrwać się z pętli z wnętrza przełącznika?

Piszę kod, który wygląda następująco:

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

Czy jest na to bezpośredni sposób?

Wiem, że mogę użyć flagi i przerwać pętlę, wstawiając warunkową przerwę tuż po przełączeniu. Chcę tylko wiedzieć, czy C ++ ma już jakąś konstrukcję do tego.

Przesłanka

Poniższy kod należy uznać za zły format, niezależnie od języka lub pożądanej funkcjonalności:

while( true ) {
}

Argumenty wspierające

while( true )Pętla jest słaba postać ponieważ:

• Przerywa domniemany kontrakt pętli while.
  • Deklaracja pętli while powinna jawnie określać jedyny warunek wyjścia.
• Sugeruje, że zapętla się w nieskończoność.
  • Aby zrozumieć klauzulę kończącą, należy odczytać kod w pętli.
  • Pętle, które powtarzają się w nieskończoność, uniemożliwiają użytkownikowi zakończenie programu z poziomu programu.
• Jest nieefektywny.
  • Istnieje wiele warunków zakończenia pętli, w tym sprawdzanie wartości „prawda”.
• Jest podatny na błędy.
  • Nie można łatwo określić, gdzie umieścić kod, który będzie zawsze wykonywany dla każdej iteracji.
• Prowadzi do niepotrzebnie złożonego kodu.
• Automatyczna analiza kodu źródłowego.
  • W celu znalezienia błędów, analizy złożoności programu, kontroli bezpieczeństwa lub automatycznego wyprowadzenia dowolnego innego zachowania kodu źródłowego bez wykonywania kodu, określenie początkowych warunków zerwania umożliwia algorytmom określenie przydatnych niezmienników, poprawiając w ten sposób wskaźniki automatycznej analizy kodu źródłowego.
• Nieskończone pętle.
  • Jeśli wszyscy zawsze używają while(true)pętli, które nie są nieskończone, tracimy zdolność do zwięzłego komunikowania się, gdy pętle w rzeczywistości nie mają warunku zakończenia. (Prawdopodobnie to już się stało, więc kwestia jest dyskusyjna.)

Alternatywa dla „Idź do”

Poniższy kod jest lepszą formą:

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

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

Zalety

Bez flagi. Nie goto. Bez wyjątku. Łatwe do zmiany. Łatwe do odczytania. Łatwe do naprawienia. Dodatkowo kod:

1. Izoluje wiedzę o obciążeniu pętli od samej pętli.
2. Pozwala osobie obsługującej kod na łatwe rozszerzenie funkcjonalności.
3. Umożliwia przypisanie wielu warunków zakończenia w jednym miejscu.
4. Oddziela klauzulę kończącą od kodu do wykonania.
5. Jest bezpieczniejszy dla elektrowni jądrowych. ;-)

Druga kwestia jest ważna. Nie wiedząc, jak działa kod, gdyby ktoś poprosił mnie o zrobienie głównej pętli, aby inne wątki (lub procesy) miały trochę czasu procesora, przychodzą mi na myśl dwa rozwiązania:

Opcja 1

Łatwo wstaw pauzę:

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

Opcja 2

Zastąp wykonaj:

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

Ten kod jest prostszy (dzięki temu łatwiejszy do odczytania) niż pętla z osadzonym switch. isValidStateMetoda powinna określić tylko wtedy, gdy pętla powinna kontynuować. Koń roboczy metody powinien zostać wyabstrahowany do executemetody, co umożliwia podklasom przesłonięcie domyślnego zachowania (trudne zadanie przy użyciu osadzonych switchi goto).

Przykład Pythona

Porównaj następującą odpowiedź (na pytanie w Pythonie), która została opublikowana w StackOverflow:

1. Pętla na zawsze.
2. Poproś użytkownika o wprowadzenie swojego wyboru.
3. Jeśli wprowadzeniem użytkownika jest „restart”, kontynuuj pętlę w nieskończoność.
4. W przeciwnym razie przestań na zawsze zapętlić.
5. Koniec.

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

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

print 'Break!' 

Przeciw:

1. Zainicjuj wybór użytkownika.
2. Pętla, podczas gdy wybór użytkownika to słowo „restart”.
3. Poproś użytkownika o wprowadzenie swojego wyboru.
4. Koniec.

choice = 'restart';

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

print 'Break!'

Tutaj while Trueskutkuje wprowadzającym w błąd i zbyt złożonym kodem.

Możesz użyć goto.

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

   }
}
exit_loop: ;

Alternatywnym rozwiązaniem jest użycie słowa kluczowego continuew połączeniu z breaknp .:

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

Użyj continueinstrukcji, aby zakończyć każdą etykietę przypadku, w której chcesz, aby pętla była kontynuowana, i użyj breakinstrukcji, aby zakończyć etykiety przypadku, które powinny zakończyć pętlę.

Oczywiście to rozwiązanie działa tylko wtedy, gdy po instrukcji switch nie ma dodatkowego kodu do wykonania.

Zgrabnym sposobem na zrobienie tego byłoby umieszczenie tego w funkcji:

int yourfunc() {

    while(true) {

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

    }
}

Opcjonalnie (ale „złe praktyki”): jak już sugerowano, możesz użyć goto lub zgłosić wyjątek wewnątrz przełącznika.

AFAIK nie ma „podwójnego przerwania” ani podobnej konstrukcji w C ++. Najbliższa byłaby a goto- która, choć ma złe konotacje ze swoją nazwą, istnieje w języku z jakiegoś powodu - o ile jest używana ostrożnie i oszczędnie, jest to realna opcja.

Możesz umieścić swój przełącznik w oddzielnej funkcji, takiej jak ta:

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

Nawet jeśli nie lubisz goto, nie używaj wyjątku do wyjścia z pętli. Poniższy przykład pokazuje, jak brzydki może być:

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

Użyłbym gotojak w tej odpowiedzi. W takim przypadku gotokod będzie bardziej przejrzysty niż każda inna opcja. Mam nadzieję, że to pytanie będzie pomocne.

Ale myślę, że użycie gotojest tutaj jedyną opcją ze względu na ciąg while(true). Powinieneś rozważyć refaktoryzację swojej pętli. Przypuszczam, że następujące rozwiązanie:

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

Lub nawet następujące:

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

W tym przypadku nie ma konstrukcji C ++ do wyrwania się z pętli.

Użyj flagi, aby przerwać pętlę lub (jeśli to konieczne) wyodrębnij kod do funkcji i użyj return.

Potencjalnie możesz użyć goto, ale wolałbym ustawić flagę, która zatrzymuje pętlę. Następnie wyłam się z przełącznika.

Dlaczego po prostu nie naprawić stanu w pętli while, powodując zniknięcie problemu?

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

Nie, C ++ nie ma takiej konstrukcji, biorąc pod uwagę, że słowo kluczowe „break” jest już zarezerwowane na wyjście z bloku przełącznika. Alternatywnie może wystarczyć do..while () z flagą wyjścia.

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

Myślę;

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

Najprostszym sposobem jest wprowadzenie prostego JEŻELI przed wykonaniem PRZEŁĄCZNIKA, a jeśli przetestujesz swój warunek wyjścia z pętli .......... tak proste, jak to tylko możliwe

Słowo breakkluczowe w C ++ kończy tylko najbardziej zagnieżdżoną iterację lub switchinstrukcję. Dlatego nie można było wyjść z while (true)pętli bezpośrednio w switchinstrukcji; jednak możesz użyć następującego kodu, który moim zdaniem jest doskonałym wzorcem dla tego typu problemów:

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

    //...
    }
}

Jeśli trzeba było coś zrobić, gdy msg->statejest równe DONE(na przykład uruchomić procedurę czyszczenia), należy umieścić ten kod bezpośrednio po forpętli; czyli jeśli obecnie masz:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Następnie użyj zamiast tego:

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

    //...
    }
}

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

Zdumiewa mnie, jak proste jest to, biorąc pod uwagę głębokość wyjaśnień ... Oto wszystko, czego potrzebujesz ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL!! Naprawdę! To wszystko, czego potrzebujesz! Jedna dodatkowa zmienna!

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

Mam ten sam problem i rozwiązałem go za pomocą flagi.

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

Jeśli dobrze pamiętam składnię C ++, możesz dodać etykietę do breakinstrukcji, tak jak w przypadku goto. Więc to, co chcesz, można łatwo napisać:

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