Usar continuar en una declaración de cambio

Quiero saltar desde el medio de una switchdeclaración a la declaración de bucle en el siguiente 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();
}

¿Es esta una forma válida de uso continue? ¿Las continuedeclaraciones ignoran las switchdeclaraciones? ¿C y C ++ difieren en su comportamiento aquí?

Está bien, la continuedeclaración se relaciona con el bucle adjunto y su código debe ser equivalente a (evitar tales declaraciones de salto):

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

Pero si espera breaksalir del ciclo, como sugiere su comentario (siempre intenta nuevamente con otro algo, hasta que se evalúa como falso), necesitará una estructura diferente.

Por ejemplo:

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

Sí, está bien, es como usarlo en una ifdeclaración. Por supuesto, no puede usar a breakpara salir de un bucle desde el interior de un interruptor.

Sí, continue será ignorado por la instrucción switch y pasará a la condición del bucle que se probará. Me gustaría compartir este extracto de la referencia del lenguaje de programación C de Ritchie:

La continuedeclaración está relacionada con break, pero se usa con menos frecuencia; que hace que la próxima iteración del for, whileo dode bucle para empezar. En whiley do, esto significa que la parte de prueba se ejecuta inmediatamente; en el for, el control pasa al paso de incremento.

La instrucción continue se aplica solo a bucles, no a una switchinstrucción. Un continuedentro de un switchinterior de un bucle provoca la siguiente iteración del bucle.

No estoy seguro de eso para C ++.

Es sintácticamente correcto y estilísticamente correcto.

Un buen estilo requiere que cada case:declaración debe terminar con una de las siguientes:

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

Además, siguiendo case (x):inmediatamente con

 case (y):
 default:

está permitido: agrupar varios casos que tienen exactamente el mismo efecto.

Todo lo demás se sospecha que es un error, al igual que if(a=4){...} Por supuesto que es necesario encerrar bucle ( while, for, do...while) para continueel trabajo. No volverá a estar case()solo. Pero una construcción como:

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

...está bien.

Si bien son técnicamente válidos, todos estos saltos oscurecen el flujo de control, especialmente la continuedeclaración.

Usaría ese truco como último recurso, no como primer recurso.

Qué tal si

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

Es más corto y realiza su trabajo de una manera más clara.

Esto puede ser un megabit demasiado tarde, pero puede usarlo continue 2.

Algunas compilaciones / configuraciones de php mostrarán esta advertencia:

Advertencia de PHP: el interruptor de orientación "continuar" es equivalente a "romper". ¿Quiso usar "continue 2"?

Por ejemplo:

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

Esto dará como resultado:

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

Probado con PHP 5.5 y superior.

El interruptor no se considera un bucle, por lo que no puede usar Continuar dentro de una declaración de caso en el interruptor ...