¿Cómo salir de un bucle desde el interior de un interruptor?

Estoy escribiendo un código que se parece a esto:

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        break; // **HERE, I want to break out of the loop itself**
    }
}

¿Hay alguna forma directa de hacerlo?

Sé que puedo usar una bandera y romper el ciclo poniendo un salto condicional justo después del cambio. Solo quiero saber si C ++ ya tiene alguna construcción para esto.

Premisa

El siguiente código debe considerarse de mala forma, independientemente del idioma o la funcionalidad deseada:

while( true ) {
}

Argumentos de apoyo

El while( true )bucle es de mala forma porque:

• Rompe el contrato implícito de un bucle while.
  • La declaración del ciclo while debe indicar explícitamente la única condición de salida.
• Implica que se repite para siempre.
  • Se debe leer el código dentro del bucle para comprender la cláusula de terminación.
  • Los bucles que se repiten para siempre evitan que el usuario finalice el programa desde dentro del programa.
• Es ineficaz.
  • Hay varias condiciones de terminación de bucle, incluida la comprobación de "verdadero".
• Es propenso a los errores.
  • No se puede determinar fácilmente dónde colocar el código que siempre se ejecutará para cada iteración.
• Conduce a un código innecesariamente complejo.
• Análisis automático de código fuente.
  • Para encontrar errores, análisis de complejidad del programa, verificaciones de seguridad o derivar automáticamente cualquier otro comportamiento del código fuente sin la ejecución del código, especificar las condiciones iniciales de ruptura permite que los algoritmos determinen invariantes útiles, mejorando así las métricas de análisis automático del código fuente.
• Bucles infinitos.
  • Si todo el mundo siempre usa while(true)bucles for que no son infinitos, perdemos la capacidad de comunicarnos de manera concisa cuando los bucles en realidad no tienen una condición de terminación. (Podría decirse que esto ya sucedió, por lo que el punto es discutible).

Alternativa a "Ir a"

El siguiente código es una mejor forma:

while( isValidState() ) {
  execute();
}

bool isValidState() {
  return msg->state != DONE;
}

Ventajas

Sin bandera. No se goto. Sin excepción. Fácil de cambiar. Fácil de leer. Fácil de arreglar. Además el código:

1. Aísla el conocimiento de la carga de trabajo del ciclo del propio ciclo.
2. Permite a alguien que mantiene el código ampliar fácilmente la funcionalidad.
3. Permite que se asignen múltiples condiciones de terminación en un solo lugar.
4. Separa la cláusula de terminación del código a ejecutar.
5. Es más seguro para las centrales nucleares. ;-)

El segundo punto es importante. Sin saber cómo funciona el código, si alguien me pide que haga que el bucle principal deje que otros subprocesos (o procesos) tengan algo de tiempo de CPU, se me ocurren dos soluciones:

Opción 1

Inserte fácilmente la pausa:

while( isValidState() ) {
  execute();
  sleep();
}

Opcion 2

Anular ejecutar:

void execute() {
  super->execute();
  sleep();
}

Este código es más simple (por lo tanto, más fácil de leer) que un bucle con un archivo switch. El isValidStatemétodo solo debe determinar si el ciclo debe continuar. El caballo de batalla del método debe abstraerse en el executemétodo, lo que permite que las subclases anulen el comportamiento predeterminado (una tarea difícil con un switchy incorporado goto).

Ejemplo de Python

Compare la siguiente respuesta (a una pregunta de Python) que se publicó en StackOverflow:

1. Bucle para siempre.
2. Pídale al usuario que ingrese su elección.
3. Si la entrada del usuario es 'reiniciar', continúa repitiendo para siempre.
4. De lo contrario, deje de hacer bucles para siempre.
5. Final.

while True: 
    choice = raw_input('What do you want? ')

    if choice == 'restart':
        continue
    else:
        break

print 'Break!' 

Versus:

1. Inicialice la elección del usuario.
2. Bucle mientras la elección del usuario es la palabra 'reiniciar'.
3. Pídale al usuario que ingrese su elección.
4. Final.

choice = 'restart';

while choice == 'restart': 
    choice = raw_input('What do you want? ')

print 'Break!'

Aquí, while Trueresulta en un código engañoso y demasiado complejo.

Puede utilizar goto.

while ( ... ) {
   switch( ... ) {
     case ...:
         goto exit_loop;

   }
}
exit_loop: ;

Una solución alternativa es usar la palabra clave continueen combinación con break, es decir:

for (;;) {
    switch(msg->state) {
    case MSGTYPE
        // code
        continue; // continue with loop
    case DONE:
        break;
    }
    break;
}

Use la continuedeclaración para terminar cada etiqueta de caso donde desea que continúe el ciclo y use la breakdeclaración para terminar las etiquetas de caso que deberían terminar el ciclo.

Por supuesto, esta solución solo funciona si no hay código adicional para ejecutar después de la instrucción de cambio.

Una forma ordenada de hacer esto sería poner esto en una función:

int yourfunc() {

    while(true) {

        switch(msg->state) {
        case MSGTYPE: // ... 
            break;
        // ... more stuff ...
        case DONE:
            return; 
        }

    }
}

Opcionalmente (pero 'malas prácticas'): como ya se sugirió, podría usar un goto o lanzar una excepción dentro del interruptor.

AFAIK no hay "doble ruptura" o construcción similar en C ++. El más cercano sería un goto, que, si bien tiene una mala connotación en su nombre, existe en el idioma por una razón, siempre que se use con cuidado y con moderación, es una opción viable.

Podría poner su interruptor en una función separada como esta:

bool myswitchfunction()
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        return false; // **HERE, I want to break out of the loop itself**
    }
    return true;
}

while(myswitchfunction())
    ;

Incluso si no le gusta goto, no use una excepción para salir de un bucle. El siguiente ejemplo muestra lo feo que podría ser:

try {
  while ( ... ) {
    switch( ... ) {
      case ...:
        throw 777; // I'm afraid of goto
     }
  }
}
catch ( int )
{
}

Usaría gotocomo en esta respuesta. En este caso goto, el código será más claro que cualquier otra opción. Espero que esta pregunta sea de ayuda.

Pero creo que usar gotoes la única opción aquí debido a la cadena while(true). Debería considerar la refactorización de su bucle. Supongo la siguiente solución:

bool end_loop = false;
while ( !end_loop ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        end_loop = true; break;
    }
}

O incluso lo siguiente:

while ( msg->state != DONE ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
}

No hay una construcción de C ++ para salir del ciclo en este caso.

Use una bandera para interrumpir el ciclo o (si corresponde) extraiga su código en una función y use return.

Potencialmente, podría usar goto, pero preferiría establecer una bandera que detenga el bucle. Luego salga del interruptor.

¿Por qué no arreglar la condición en su bucle while, haciendo que el problema desaparezca?

while(msg->state != DONE)
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        // We can't get here, but for completeness we list it.
        break; // **HERE, I want to break out of the loop itself**
    }
}

No, C ++ no tiene una construcción para esto, dado que la palabra clave "break" ya está reservada para salir del bloque de interruptores. Alternativamente, un do.. while () con una bandera de salida podría ser suficiente.

do { 
    switch(option){
        case 1: ..; break;
        ...
        case n: .. ;break;
        default: flag = false; break;
    }
} while(flag);

Yo creo que;

while(msg->state != mExit) 
{
    switch(msg->state) 
    {
      case MSGTYPE: // ...
         break;
      case DONE:
      //  .. 
      //  ..
      msg->state =mExit;
      break;
    }
}
if (msg->state ==mExit)
     msg->state =DONE;

La forma más sencilla de hacerlo es poner un IF simple antes de hacer el SWITCH, y que IF pruebe su condición para salir del bucle ... tan simple como puede ser

La breakpalabra clave en C ++ solo termina la iteración o switchdeclaración adjunta más anidada . Por lo tanto, no podría salir del while (true)bucle directamente dentro de la switchdeclaración; sin embargo, podría usar el siguiente código, que creo que es un patrón excelente para este tipo de problema:

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

Si necesita hacer algo cuando msg->statees igual DONE(como ejecutar una rutina de limpieza), coloque ese código inmediatamente después del forciclo; es decir, si actualmente tiene:

while (true) {
    switch (msg->state) {
    case MSGTYPE:
        //... 
        break;

    //...

    case DONE:
        do_cleanup();
        break;
    }

    if (msg->state == DONE)
        break;

    msg = next_message();
}

Luego usa en su lugar:

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

assert(msg->state == DONE);
do_cleanup();

Me sorprende lo simple que es esto considerando la profundidad de las explicaciones ... Aquí está todo lo que necesita ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL !! ¡De Verdad! ¡Eso es todo lo que necesitas! ¡Una variable extra!

while(MyCondition) {
switch(msg->state) {
case MSGTYPE: // ... 
    break;
// ... more stuff ...
case DONE:
   MyCondition=false; // just add this code and you will be out of loop.
    break; // **HERE, you want to break out of the loop itself**
}
}

Tengo el mismo problema y lo resolví usando una bandera.

bool flag = false;
while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        flag = true; // **HERE, I want to break out of the loop itself**
    }
    if(flag) break;
}

Si recuerdo bien la sintaxis de C ++, puede agregar una etiqueta a las breakdeclaraciones, como para goto. Entonces, lo que desea se escribiría fácilmente:

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ...
        break;
    // ... more stuff ...
    case DONE:
        break outofloop; // **HERE, I want to break out of the loop itself**
    }
}

outofloop:
// rest of your code here

  while(true)
  {
    switch(x)
    {
     case 1:
     {
      break;
     }
    break;
   case 2:
    //some code here
   break;
  default:
  //some code here
  }
}