die Verwendung in einer switch-Anweisung weiterhin

Question

ich aus der Mitte einer switch Anweisung springen mag, auf die Schleifenanweisung in dem folgenden Code:

while (something = get_something()) 
{ 
    switch (something) 
    { 
    case A: 
    case B: 
     break; 
    default: 
     // get another something and try again 
     continue; 
    } 
    // do something for a handled something 
    do_something(); 
} 

Ist dies eine gültige Weise continue zu benutzen? Werden continue Anweisungen von switch Anweisungen ignoriert? Unterscheiden sich C und C++ von ihrem Verhalten?

Answer 1

Es ist in Ordnung, bezieht sich die continue Anweisung an die umgebenden Schleife, und der Code sollte (Vermeidung solcher Sprunganweisungen) entsprechen:

while (something = get_something()) { 
    if (something == A || something == B) 
     do_something(); 
} 

Aber wenn Sie break erwarten, dass die Schleife verlassen, wie Sie Ihren Kommentar suggerieren (es versucht immer wieder mit einem anderen etwas, bis es falsch auswertet), du brauchst eine andere Struktur.

Zum Beispiel:

do { 
    something = get_something(); 
} while (!(something == A || something == B)); 
do_something(); 

Answer 2

Ja, es ist in Ordnung - es ist wie in einer if Aussage. Natürlich können Sie keine break verwenden, um aus einer Schleife innerhalb eines Schalters auszubrechen.

Answer 3

Während technisch gültig, all diese Sprünge obskurer Steuerfluss - vor allem der continue Aussage.

Ich würde einen solchen Trick als letztes Mittel verwenden, nicht das erste.

Wie wäre es

while (something = get_something()) 
{ 
    switch (something) 
    { 
    case A: 
    case B: 
     do_something(); 
    }   
} 

Es ist kürzer und seine Sachen in einer klaren Art und Weise durchzuführen.

Answer 4

Es ist syntaktisch korrekt und stilistisch in Ordnung.

Guter Stil erfordert jede case: Anweisung sollte mit einem der folgenden Ende:

break; 
continue; 
return (x); 
exit (x); 
throw (x); 
//fallthrough 

Zusätzlich folgende case (x): sofort mit

case (y): 
default: 

zulässig ist - mehrere Fälle zu bündeln, die genau die gleiche Wirkung haben .

sonst Alles, was vermutet wird, einen Fehler zu sein, genau wie if(a=4){...} Natürlich brauchen Sie umschließenden Schleife (while, for, do...while) für continue zu arbeiten. Es wird nicht alleine auf case() zurückgeschleift. Aber ein Konstrukt wie:

while(record = getNewRecord()) 
{ 
    switch(record.type) 
    { 
     case RECORD_TYPE_...; 
      ... 
     break; 
     default: //unknown type 
      continue; //skip processing this record altogether. 
    } 
    //...more processing... 
} 

... ist in Ordnung.

Answer 5

Ja, continue wird von der switch-Anweisung ignoriert und wechselt in den Zustand der zu testenden Schleife. Ich möchte diesen Auszug aus der C-Programmiersprache Referenz von Ritchie teilen "Die Continue-Anweisung bezieht sich auf Break, aber weniger häufig verwendet; es verursacht die nächste Iteration der umschließenden für, während oder do-Schleife zu beginnen.In der while und do bedeutet dies, dass der Testteil sofort ausgeführt wird; in dem geht die Steuerung zu dem Inkrementierungsschritt über. Die continue-Anweisung gilt nur für Schleifen, nicht zum Umschalten. Ein Fortsetzen innerhalb eines Schalters innerhalb einer Schleife bewirkt die nächste Schleifeniteration. "

Ich bin für das über C++ nicht sicher.

Answer 6

Schalter nicht als Schleife betrachtet wird, so dass Sie nicht in einer Case-Anweisung in Schalter weiter verwenden können ...