Wie kann man aus einer Schleife in einem Schalter ausbrechen?

Ich schreibe einen Code, der so aussieht:

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

Gibt es einen direkten Weg, das zu tun?

Ich weiß, dass ich ein Flag verwenden und aus der Schleife ausbrechen kann, indem ich direkt nach dem Wechsel eine bedingte Pause einlege. Ich möchte nur wissen, ob C ++ bereits ein Konstrukt dafür hat.

Prämisse

Der folgende Code sollte unabhängig von der Sprache oder der gewünschten Funktionalität als schlechte Form angesehen werden:

while( true ) {
}

Unterstützende Argumente

Die while( true )Schleife hat eine schlechte Form, weil sie:

• Bricht den impliziten Vertrag einer while-Schleife.
  • Die while-Schleifendeklaration sollte explizit die einzige Exit-Bedingung angeben.
• Impliziert, dass es für immer Schleifen.
  • Code innerhalb der Schleife muss gelesen werden, um die Abschlussklausel zu verstehen.
  • Schleifen, die sich für immer wiederholen, verhindern, dass der Benutzer das Programm innerhalb des Programms beendet.
• Ist ineffizient.
  • Es gibt mehrere Bedingungen für die Beendigung von Schleifen, einschließlich der Überprüfung auf "true".
• Ist anfällig für Fehler.
  • Es kann nicht einfach bestimmt werden, wo Code abgelegt werden soll, der immer für jede Iteration ausgeführt wird.
• Führt zu unnötig komplexem Code.
• Automatische Quellcode-Analyse.
  • Um Fehler zu finden, die Komplexität der Programme zu analysieren, Sicherheitsüberprüfungen durchzuführen oder automatisch ein anderes Verhalten des Quellcodes ohne Codeausführung abzuleiten, können Algorithmen durch Angabe der anfänglichen Unterbrechungsbedingungen nützliche Invarianten bestimmen und so die Metriken für die automatische Quellcode-Analyse verbessern.
• Endlosschleifen.
  • Wenn jeder immer while(true)Schleifen verwendet, die nicht unendlich sind, verlieren wir die Fähigkeit zur präzisen Kommunikation, wenn Schleifen tatsächlich keine Abschlussbedingung haben. (Vermutlich ist dies bereits geschehen, daher ist der Punkt umstritten.)

Alternative zu "Gehe zu"

Der folgende Code ist eine bessere Form:

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

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

Vorteile

Keine Flagge. Nein goto. Keine Ausnahmen. Einfach zu wechseln. Leicht zu lesen. Einfach zu reparieren. Zusätzlich der Code:

1. Isoliert das Wissen über die Arbeitslast der Schleife von der Schleife selbst.
2. Ermöglicht es jemandem, der den Code verwaltet, die Funktionalität einfach zu erweitern.
3. Ermöglicht die Zuweisung mehrerer Abschlussbedingungen an einem Ort.
4. Trennt die Abschlussklausel vom auszuführenden Code.
5. Ist sicherer für Kernkraftwerke. ;-);

Der zweite Punkt ist wichtig. Ohne zu wissen, wie der Code funktioniert, fallen mir zwei Lösungen ein, wenn mich jemand bittet, die Hauptschleife so zu gestalten, dass andere Threads (oder Prozesse) etwas CPU-Zeit haben:

Option 1

Fügen Sie die Pause bereitwillig ein:

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

Option 2

Überschreiben ausführen:

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

Dieser Code ist einfacher (daher leichter zu lesen) als eine Schleife mit einer eingebetteten switch. Die isValidStateMethode sollte nur bestimmen, ob die Schleife fortgesetzt werden soll. Das Arbeitspferd der Methode sollte in die executeMethode abstrahiert werden, damit Unterklassen das Standardverhalten überschreiben können (eine schwierige Aufgabe mit einem eingebetteten switchund goto).

Python-Beispiel

Vergleichen Sie die folgende Antwort (auf eine Python-Frage), die auf StackOverflow veröffentlicht wurde:

1. Schleife für immer.
2. Bitten Sie den Benutzer, seine Wahl einzugeben.
3. Wenn die Benutzereingabe "Neustart" lautet, setzen Sie die Schleife für immer fort.
4. Andernfalls hören Sie für immer auf, eine Schleife zu erstellen.
5. Ende.

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

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

print 'Break!' 

Gegen:

1. Initialisieren Sie die Auswahl des Benutzers.
2. Schleife, während der Benutzer das Wort "Neustart" auswählt.
3. Bitten Sie den Benutzer, seine Wahl einzugeben.
4. Ende.

choice = 'restart';

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

print 'Break!'

Dies while Trueführt zu irreführendem und zu komplexem Code.

Sie können verwenden goto.

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

   }
}
exit_loop: ;

Eine alternative Lösung besteht darin, das Schlüsselwort continuein Kombination mit folgenden breakElementen zu verwenden:

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

Verwenden Sie die continueAnweisung, um jede Fallbezeichnung zu beenden, an der die Schleife fortgesetzt werden soll, und verwenden Sie die breakAnweisung, um Fallbezeichnungen zu beenden, die die Schleife beenden sollen.

Natürlich funktioniert diese Lösung nur, wenn nach der switch-Anweisung kein zusätzlicher Code ausgeführt werden muss.

Ein ordentlicher Weg, dies zu tun, wäre, dies in eine Funktion zu setzen:

int yourfunc() {

    while(true) {

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

    }
}

Optional (aber "schlechte Praktiken"): Wie bereits vorgeschlagen, können Sie ein goto verwenden oder eine Ausnahme in den Switch werfen.

AFAIK gibt es in C ++ kein "Double Break" oder ähnliches Konstrukt. Das nächste wäre ein goto- das zwar eine schlechte Konnotation zu seinem Namen hat, aber aus einem bestimmten Grund in der Sprache existiert - solange es sorgfältig und sparsam verwendet wird, ist es eine praktikable Option.

Sie können Ihren Schalter wie folgt in eine separate Funktion umwandeln:

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

Auch wenn Sie goto nicht mögen, verwenden Sie keine Ausnahme, um eine Schleife zu verlassen. Das folgende Beispiel zeigt, wie hässlich es sein könnte:

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

Ich würde gotowie in dieser Antwort verwenden. In diesem Fall gotowird der Code klarer als bei jeder anderen Option. Ich hoffe, dass diese Frage hilfreich sein wird.

Aber ich denke, dass die Verwendung gotohier aufgrund der Zeichenfolge die einzige Option ist while(true). Sie sollten ein Refactoring Ihrer Schleife in Betracht ziehen. Ich würde die folgende Lösung annehmen:

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

Oder sogar das Folgende:

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

In diesem Fall gibt es kein C ++ - Konstrukt, um aus der Schleife auszubrechen.

Verwenden Sie entweder ein Flag, um die Schleife zu unterbrechen, oder extrahieren Sie (falls zutreffend) Ihren Code in eine Funktion und verwenden Sie return.

Sie könnten möglicherweise goto verwenden, aber ich würde es vorziehen, ein Flag zu setzen, das die Schleife stoppt. Dann aus dem Schalter ausbrechen.

Warum nicht einfach den Zustand in Ihrer while-Schleife beheben und das Problem verschwinden lassen?

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

Nein, C ++ hat hierfür kein Konstrukt, da das Schlüsselwort "break" bereits für das Verlassen des Switch-Blocks reserviert ist. Alternativ könnte ein do..while () mit einem Exit-Flag ausreichen.

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

Meiner Ansicht nach;

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

Der einfachste Weg, dies zu tun, besteht darin, vor dem SWITCH eine einfache IF zu setzen und diese IF Ihre Bedingung für das Verlassen der Schleife zu testen .......... so einfach wie möglich

Das breakSchlüsselwort in C ++ beendet nur die am meisten verschachtelte einschließende Iteration oder switchAnweisung. Sie konnten also nicht while (true)direkt innerhalb der switchAnweisung aus der Schleife ausbrechen . Sie können jedoch den folgenden Code verwenden, der meiner Meinung nach ein hervorragendes Muster für diese Art von Problem darstellt:

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

    //...
    }
}

Wenn Sie etwas tun müssen, wenn es msg->stategleich ist DONE(z. B. eine Bereinigungsroutine ausführen), platzieren Sie diesen Code unmittelbar nach der forSchleife. dh wenn Sie derzeit haben:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Verwenden Sie stattdessen:

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

    //...
    }
}

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

Es wundert mich, wie einfach dies angesichts der Tiefe der Erklärungen ist ... Hier ist alles, was Sie brauchen ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL !! Ja wirklich! Das ist alles was du brauchst! Eine zusätzliche Variable!

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

Ich habe das gleiche Problem und mit einer Flagge gelöst.

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

Wenn ich mich gut an die C ++ - Syntax erinnere, können Sie breakAnweisungen wie für eine Bezeichnung hinzufügen goto. Was Sie wollen, lässt sich also leicht schreiben:

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