Utilisation de continue dans une instruction de commutation

Question

Je veux sauter du milieu d'un 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 ? Est-ce que continue les déclarations ignorées par switch déclarations ? Le C et le C++ diffèrent-ils dans leur comportement à cet égard ?

Answer 1

C'est bon, le continue se rapporte à la boucle qui l'entoure, et votre code devrait être équivalent à (en évitant de telles instructions 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 le suggère (il essaie toujours de nouveau avec un autre quelque chose, jusqu'à ce qu'il soit évalué à 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, continue sera ignoré par l'instruction switch et ira à la condition de la boucle à tester. J'aimerais partager cet extrait de la référence du langage de programmation C de Ritchie "L'instruction continue est apparentée à break, mais moins souvent utilisée ; elle fait commencer l'itération suivante de la boucle for, while ou do qui l'entoure. Dans les boucles while et do, cela signifie que la partie test est exécutée immédiatement ; dans la boucle for, le contrôle passe à l'étape d'incrémentation. L'instruction continue ne s'applique qu'aux boucles, pas au switch. Un continue à l'intérieur d'un switch à l'intérieur d'une boucle provoque l'itération suivante de la boucle. "

Je n'en suis pas sûr pour le C++.

Answer 3

Oui, c'est bon, c'est comme si vous l'utilisiez dans un if déclaration. Bien entendu, vous ne pouvez pas utiliser une break pour sortir d'une boucle depuis l'intérieur d'un interrupteur.

Answer 4

C'est syntaxiquement correct et stylistiquement correct.

Un bon style exige que chaque case: La déclaration doit se terminer par l'un des éléments suivants :

 break;
 continue;
 return (x);
 case (x):
 default:
 //fallthrough

Tout le reste est suspecté 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 reviendra pas en boucle 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...
}

Answer 5

Bien qu'ils soient techniquement valables, tous ces sauts obscurcissent le flux de contrôle -- en particulier le continue déclaration.

J'utiliserais cette astuce en dernier recours, pas en premier.

Et si

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

Il est plus court et présente son contenu de manière plus claire.