web-dev-qa-db-fra.com

Utilisation de continue dans une instruction switch

Je veux passer du milieu d'une instruction switch à l'instruction loop 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 valide d'utiliser continue? Les instructions continue sont-elles ignorées par les instructions switch? C et C++ diffèrent-ils ici sur leur comportement?

c++cswitch-statementbreakcontinue
69
Matt Joiner

C'est bien, l'instruction continue se rapporte à la boucle englobante, et votre code devrait être équivalent à (éviter de telles instructions de saut):

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

Mais si vous vous attendez à ce que break quitte la boucle, comme le suggère votre commentaire (il essaie toujours à nouveau avec un autre quelque chose, jusqu'à ce qu'il soit faux), vous aurez besoin d'une structure différente.

Par exemple:

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

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

20
anon

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

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

L'instruction continue ne s'applique qu'aux boucles, pas à une instruction switch. Un continue à l'intérieur d'un switch à l'intérieur d'une boucle provoque l'itération de boucle suivante.

Je ne suis pas sûr de cela pour C++.

10
Islam Elshahat

C'est syntaxiquement correct et stylistiquement correct.

Un bon style requiert que chaque instruction case: Se termine par l'un des éléments suivants:

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

De plus, en suivant case (x): immédiatement avec

 case (y):
 default:

est autorisé - regroupant plusieurs cas qui ont exactement le même effet.

Tout autre élément est soupçonné d’être une erreur, tout comme if(a=4){...} Bien sûr, vous avez besoin d’une boucle englobante (while, for, do...while) Pour continue pour travailler. Il ne rebouclera pas sur 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.

7
SF.

Bien que techniquement valables, tous ces sauts obscurcissent le flux de contrôle - en particulier l'instruction continue.

J'utiliserais une telle astuce en dernier recours, pas en premier.

Que diriez-vous

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

Il est plus court et effectue ses tâches de manière plus claire.

5
Alexander Poluektov