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

Puede usar goto.

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

   }
}
exit_loop: ;

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

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

Use la instrucción continue para terminar cada etiqueta de caso donde desea que el bucle continúe y use la instrucción break para terminar las etiquetas de caso que deben terminar el bucle.

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

Una manera neatish 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 ha sugerido, 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 a su nombre, existe en el lenguaje por una razón - siempre y cuando se use con cuidado y moderación, es una opción viable.

Usted 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 hará que el código sea más claro que cualquier otra opción. Espero que esta pregunta sea útil.

Pero creo que usar goto es la única opción aquí debido a la cadena while(true). Deberías considerar refactorizar tu bucle. Supongo que lo 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 C++ para romper el bucle en este caso.

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

Podría usar goto, pero preferiría establecer una bandera que detenga el bucle. Entonces sal del interruptor.

¿Por qué no simplemente 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 switch. Alternativamente un do..while () con un indicador de salida podría ser suficiente.

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

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 simple IF antes de hacer el SWITCH , y que SI pruebe su condición para salir del bucle .......... tan simple como puede ser

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

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

    //...
    }
}

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

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Entonces use 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 necesitas...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL!! ¡En serio! ¡Eso es todo lo que necesitas! Una variable adicional!

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 resuelto 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 sentencias break, al igual que para goto. Así que lo que quieres 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
  }
}