Utilizzo di continue in un'istruzione switch

Voglio passare dal centro di switchun'istruzione all'istruzione loop nel codice seguente:

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

È questo un modo valido per utilizzare continue? Le continuedichiarazioni vengono ignorate dalle switchdichiarazioni? C e C ++ differiscono nel loro comportamento qui?

Va bene, l' continueistruzione si riferisce al ciclo che lo racchiude e il tuo codice dovrebbe essere equivalente a (evitare tali istruzioni di salto):

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

Ma se ti aspetti breakdi uscire dal ciclo, come suggerisce il tuo commento (riprova sempre con qualcos'altro, fino a quando non diventa falso), avrai bisogno di una struttura diversa.

Per esempio:

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

Sì, va bene, è come usarlo in una ifdichiarazione. Ovviamente, non puoi usare a breakper uscire da un loop dall'interno di un interruttore.

Sì, continue verrà ignorato dall'istruzione switch e andrà alla condizione del ciclo da testare. Vorrei condividere questo estratto dal riferimento al linguaggio di programmazione C di Ritchie:

L' continueaffermazione è correlata a break, ma usata meno spesso; provoca la successiva iterazione del racchiude for, whileo dociclo per iniziare. In whilee do, questo significa che la parte di test viene eseguita immediatamente; in for, il controllo passa alla fase di incremento.

L'istruzione continue si applica solo ai cicli, non a switchun'istruzione. Un continueall'interno di un switchall'interno di un ciclo provoca l'iterazione del ciclo successivo.

Non ne sono sicuro per C ++.

È sintatticamente corretto e stilisticamente corretto.

Un buon stile richiede che ogni case:affermazione finisca con uno dei seguenti:

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

Inoltre, case (x):subito dopo con

 case (y):
 default:

è consentito - raggruppare più custodie che hanno esattamente lo stesso effetto.

Tutto il resto è sospettato di essere un errore, proprio come if(a=4){...} naturalmente è necessario che racchiude loop ( while, for, do...while) per continueil lavoro. Non tornerà da case()solo. Ma un costrutto come:

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

...va bene.

Sebbene tecnicamente validi, tutti questi salti oscurano il flusso di controllo, specialmente l' continueaffermazione.

Userei un trucco del genere come ultima risorsa, non come prima.

Che ne dite di

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

È più breve ed esegue le sue cose in modo più chiaro.

Questo potrebbe essere un megabit in ritardo, ma puoi usare continue 2.

Alcune build / configurazioni php restituiranno questo avviso:

Avviso PHP: l'interruttore di targeting "continue" equivale a "interruzione". Volevi usare "continue 2"?

Per esempio:

$i = 1;

while ($i <= 10) {
    $mod = $i % 4;
    echo "\r\n out $i";
    $i++;
    switch($mod)
    {
        case 0:
            break;
        case 2:
            continue;
            break;
        default:
            continue 2;
            break;
    }
    echo " is even";
}

Questo produrrà:

out 1
out 2 is even
out 3
out 4 is even
out 5
out 6 is even
out 7
out 8 is even
out 9
out 10 is even

Testato con PHP 5.5 e versioni successive.

Switch non è considerato come loop, quindi non puoi usare Continue all'interno di un'istruzione case in switch ...