dans une Utilisation continue instruction switch

Question

Je veux sauter à partir du milieu d'une déclaration switch, à l'instruction de boucle dans le code suivant:

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

Est-ce un moyen valable d'utiliser continue? Les instructions continue sont-elles ignorées par les instructions switch? Est-ce que C et C++ diffèrent sur leur comportement ici?

Answer 1

Il est très bien, la déclaration continue se rapporte à la boucle englobante et votre code devrait être équivalent à (éviter de telles déclarations de saut):

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

Mais si vous vous attendez break pour sortir de la boucle, comme votre commentaire suggérer (il essaie toujours encore avec un autre quelque chose, jusqu'à ce qu'il évalue à faux), vous aurez besoin d'une structure différente.

Par exemple:

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

Answer 2

Oui, c'est OK - c'est comme si vous l'utilisiez dans une instruction if. Bien sûr, vous ne pouvez pas utiliser un break pour sortir d'une boucle à l'intérieur d'un commutateur.

Answer 3

Bien que techniquement valides, tous ces sauts de flux de contrôle obscur - en particulier la déclaration continue.

Je voudrais utiliser une telle astuce en dernier recours, pas le premier.

Que diriez-vous

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

Il est plus court et exécuter ses choses d'une manière plus claire.

Answer 4

C'est syntaxiquement correct et stylistiquement correct.

Un bon style exige que chaque déclaration case: doit se terminer par une des opérations suivantes:

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

De plus, à la suite case (x): immédiatement avec

case (y): 
default: 

est admissible - regrouper plusieurs cas qui ont exactement le même effet .

Tout le reste est soupçonné d'être une erreur, tout comme if(a=4){...} Bien sûr, vous devez boucle enfermant (while, for, do...while) pour continue travailler. Il ne reviendra pas à case() seul. Mais une construction comme:

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

... c'est correct.

Answer 5

Oui, continuer sera ignoré par l'instruction switch et passera à l'état de la boucle à tester. Je voudrais partager cet extrait de la référence C Programming Language par Ritchie "L'instruction continue est liée à break, mais moins souvent utilisée, elle provoque le début de l'itération suivante de la boucle for, while ou do.Dans le temps et le faire, cela signifie que la partie test est exécutée immédiatement; dans le cas de, le contrôle passe à l'étape d'incrément. L'instruction continue s'applique uniquement aux boucles, ne pas basculer. Une continuation à l'intérieur d'un commutateur à l'intérieur d'une boucle provoque l'itération de la boucle suivante. "

Je ne suis pas sûr que C++.

Answer 6

Switch est pas considéré comme boucle de sorte que vous ne pouvez pas utiliser Continuer dans une déclaration de cas dans le commutateur ...