Utilisation de continuer dans une instruction switch

Question

Je veux sauter à partir du milieu d'une déclaration de 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 une façon valable d'utiliser continue? Sont des déclarations continue ignorées par les déclarations de switch? Est-ce que C et C ++ diffèrent sur leur comportement ici?

Answer 1

Il est très bien, la déclaration de 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ère (il essaie toujours de nouveau avec une autre chose, jusqu'à ce qu'il évalue à false), vous aurez besoin d'une structure différente.

Par exemple:

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

Answer 2

Oui, il est OK - il est tout comme l'utiliser 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

Oui, continuer sera ignorée par l'instruction switch et ira à la condition de la boucle à tester. Je voudrais partager cet extrait de programmation C Référence du langage par Ritchie:

  

L'instruction continue est liée à break, mais moins souvent utilisé; il provoque l'itération suivante de la enfermant for, while ou boucle de do commencer. Dans le while et do, cela signifie que la partie de test est exécuté immédiatement; dans le for, la commande passe à l'étape d'incrémentation.

     

L'instruction continue applique uniquement aux boucles, pas à une déclaration de switch. A l'intérieur d'un continue switch intérieur d'une boucle provoque l'itération suivante de la boucle.

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

Answer 4

Il est syntaxiquement correct et stylistiquement correct.

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

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

En outre, à la suite case (x): immédiatement avec

 case (y):
 default:

est admissible -. L'assemblage de 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 sera pas de retour en boucle à 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...
}

... est correct.

Answer 5

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

J'utiliser un tel truc en dernier ressort, pas premier.

Qu'en est-

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