Usando continue em uma instrução switch

Quero pular do meio de uma switchinstrução para a instrução de loop no seguinte código:

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

Esta é uma forma válida de usar continue? As continuedeclarações são ignoradas pelas switchdeclarações? C e C ++ diferem em seu comportamento aqui?

Tudo bem, a continueinstrução está relacionada ao loop envolvente e seu código deve ser equivalente a (evitando essas instruções de salto):

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

Mas se você espera break sair do loop, como seu comentário sugere (ele sempre tenta novamente com outro algo, até que seja avaliado como falso), você precisará de uma estrutura diferente.

Por exemplo:

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

Sim, está tudo bem - é como usá-lo em uma ifdeclaração. Claro, você não pode usar um breakpara sair de um loop de dentro de um switch.

Sim, continue será ignorado pela instrução switch e irá para a condição do loop a ser testado. Eu gostaria de compartilhar este trecho da referência da Linguagem de Programação C feita por Ritchie:

A continuedeclaração está relacionada a break, mas usada com menos frequência; isso faz com que a próxima iteração do anexando for, whileou doloop para começar. No whilee do, isso significa que a parte de teste é executada imediatamente; no for, o controle passa para a etapa de incremento.

A instrução continue se aplica apenas a loops, não a uma switchinstrução. Um continuedentro de um switchloop causa a próxima iteração do loop.

Não tenho certeza sobre isso para C ++.

É sintaticamente correto e estilisticamente correto.

O bom estilo exige que cada case:declaração termine com um dos seguintes:

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

Além disso, seguindo case (x):imediatamente com

 case (y):
 default:

é permitido - agrupar vários casos que têm exatamente o mesmo efeito.

Qualquer outra coisa é suspeito de ser um erro, assim como if(a=4){...} Claro que você precisa encerrando loop ( while, for, do...while) para continueo trabalho. Não vai voltar a case()ficar sozinho. Mas uma construção como:

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

...esta bem.

Embora tecnicamente válidos, todos esses saltos obscurecem o fluxo de controle - especialmente a continueinstrução.

Eu usaria esse truque como último recurso, não o primeiro.

E se

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

É mais curto e tem um desempenho mais claro.

Isso pode demorar um megabit, mas você pode usar continue 2.

Algumas compilações / configurações de php exibirão este aviso:

Aviso do PHP: a opção de direcionamento "continue" é equivalente a "break". Você quis dizer usar "continue 2"?

Por exemplo:

$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";
}

Isso resultará em:

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

Testado com PHP 5.5 e superior.

Switch não é considerado um loop, então você não pode usar Continue dentro de uma instrução case em switch ...