c++ - tipos - Usando continuar en una instrucción de cambio

tipos de tags en rslogix 5000

Question

Quiero saltar desde la mitad de una instrucción switch a la instrucción loop 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 usar continue ? ¿Se ignoran las instrucciones de continue instrucciones de switch ? ¿C y C ++ difieren en su comportamiento aquí?

Answer 1

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

Answer 2

Es sintácticamente correcto y estilísticamente bien.

El buen estilo requiere todos los case: declaración debe terminar con uno de los siguientes:

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

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

 case (y):
 default:

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

Se sospecha que cualquier otra cosa es un error, como if(a=4){...} Por supuesto, necesita un bucle adjunto ( while , for , do...while ) para continue trabajando. No volverá al 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.

Answer 3

Está bien, la declaración de continue relaciona con el bucle adjunto, y su código debe ser equivalente a (evitando dichas declaraciones de salto):

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

Pero si espera que la break salga del bucle, como sugiere su comentario (siempre intenta otra cosa, hasta que se evalúa como falsa), necesitará una estructura diferente.

Por ejemplo:

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

Answer 4

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

La declaración de continue está relacionada con la break , pero se usa con menos frecuencia; hace que comience la siguiente iteración del encierre for , while o do loop. En el while y 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 solo se aplica a los bucles, no a una instrucción switch . Una continue dentro de un switch dentro de un bucle provoca la siguiente iteración del bucle.

No estoy seguro de eso para C ++.

Answer 5

Sí, está bien, es como usarlo en una declaración if . Por supuesto, no puede usar una break para salir de un bucle desde dentro de un interruptor.

Answer 6

Si bien es técnicamente válido, todos estos saltos oscurecen el flujo de control, especialmente la declaración de continue .

Yo usaría un truco como último recurso, no el primero.

Qué tal si

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

Es más corto y realiza sus cosas de una manera más clara.