Como sair de um loop de dentro de um switch?

Estou escrevendo um código parecido com este:

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

Existe alguma maneira direta de fazer isso?

Sei que posso usar um sinalizador e interromper o loop colocando uma quebra condicional logo após a troca. Só quero saber se o C ++ já tem alguma construção para isso.

Premissa

O código a seguir deve ser considerado um formato incorreto, independentemente do idioma ou da funcionalidade desejada:

while( true ) {
}

Argumentos de Apoio

O while( true )loop é de má forma porque:

• Quebra o contrato implícito de um loop while.
  • A declaração do loop while deve indicar explicitamente a única condição de saída.
• Implica que ele faz um loop para sempre.
  • O código dentro do loop deve ser lido para compreender a cláusula de terminação.
  • Os loops que se repetem para sempre evitam que o usuário finalize o programa de dentro do programa.
• É ineficiente.
  • Existem várias condições de encerramento do loop, incluindo a verificação de "verdadeiro".
• Está sujeito a bugs.
  • Não é possível determinar facilmente onde colocar o código que sempre será executado para cada iteração.
• Leva a um código desnecessariamente complexo.
• Análise automática de código-fonte.
  • Para encontrar bugs, análise de complexidade de programa, verificações de segurança ou derivar automaticamente qualquer outro comportamento de código-fonte sem execução de código, a especificação da (s) condição (ões) de quebra inicial permite que os algoritmos determinem invariantes úteis, melhorando assim as métricas de análise automática de código-fonte.
• Loops infinitos.
  • Se todo mundo sempre usa while(true)loops for que não são infinitos, perdemos a capacidade de nos comunicarmos concisamente quando os loops, na verdade, não têm condição de terminação. (Provavelmente, isso já aconteceu, então a questão é discutível.)

Alternativa para "Ir para"

O código a seguir é melhor:

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

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

Vantagens

Sem bandeira. Não goto. Sem exceção. Fácil de mudar. Fácil de ler. Fácil de consertar. Além disso, o código:

1. Isola o conhecimento da carga de trabalho do loop do próprio loop.
2. Permite que alguém que mantém o código estenda facilmente a funcionalidade.
3. Permite que várias condições de encerramento sejam atribuídas em um só lugar.
4. Separa a cláusula de terminação do código a ser executado.
5. É mais seguro para usinas nucleares. ;-)

O segundo ponto é importante. Sem saber como o código funciona, se alguém me pedir para fazer o loop principal permitir que outros threads (ou processos) tenham algum tempo de CPU, duas soluções vêm à mente:

Opção 1

Insira prontamente a pausa:

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

Opção 2

Substituir executar:

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

Este código é mais simples (portanto, mais fácil de ler) do que um loop com um incorporado switch. O isValidStatemétodo deve determinar apenas se o loop deve continuar. O burro de carga do método deve ser abstraído no executemétodo, o que permite que as subclasses substituam o comportamento padrão (uma tarefa difícil usando um switchegoto ).

Exemplo Python

Compare a seguinte resposta (a uma pergunta Python) que foi postada no StackOverflow:

1. Loop para sempre.
2. Peça ao usuário para inserir sua escolha.
3. Se a entrada do usuário for 'reiniciar', continue o loop para sempre.
4. Caso contrário, pare de repetir para sempre.
5. Fim.

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

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

print 'Break!' 

Versus:

1. Inicialize a escolha do usuário.
2. Loop enquanto a escolha do usuário é a palavra 'reiniciar'.
3. Peça ao usuário para inserir sua escolha.
4. Fim.

choice = 'restart';

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

print 'Break!'

Aqui, while Trueresulta em código enganoso e excessivamente complexo.

Você pode usar goto.

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

   }
}
exit_loop: ;

Uma solução alternativa é usar a palavra-chave continueem combinação com break, ou seja:

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

Use a continueinstrução para terminar cada rótulo de caso em que deseja que o loop continue e use obreak instrução para terminar os rótulos de caso que devem encerrar o loop.

É claro que essa solução só funciona se não houver código adicional a ser executado após a instrução switch.

Uma maneira elegante de fazer isso seria colocar isso em uma função:

int yourfunc() {

    while(true) {

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

    }
}

Opcionalmente (mas 'más práticas'): como já sugerido, você pode usar um goto ou lançar uma exceção dentro do switch.

AFAIK não há "quebra dupla" ou construção semelhante em C ++. O mais próximo seria um goto- que, embora tenha uma conotação ruim para seu nome, existe na língua por uma razão - desde que usado com cuidado e parcimônia, é uma opção viável.

Você pode colocar seu switch em uma função 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())
    ;

Mesmo se você não gostar de goto, não use uma exceção para sair de um loop. O exemplo a seguir mostra como isso pode ser feio:

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

Eu usaria gotocomo nesta resposta. Nesse caso goto, o código ficará mais claro do que qualquer outra opção. Espero que esta pergunta seja útil.

Mas acho que usar gotoé a única opção aqui por causa da string while(true). Você deve considerar a refatoração de seu loop. Suponho que a seguinte solução:

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

Ou mesmo o seguinte:

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

Não há construção C ++ para quebrar o loop neste caso.

Use um sinalizador para interromper o loop ou (se apropriado) extraia seu código em uma função e use return.

Você poderia usar goto, mas prefiro definir um sinalizador que interrompa o loop. Em seguida, saia do interruptor.

Por que não apenas corrigir a condição em seu loop while, fazendo com que o problema desapareça?

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**
    }
}

Não, C ++ não possui uma construção para isso, visto que a palavra-chave "break" já está reservada para sair do bloco switch. Alternativamente, um do..while () com um sinalizador de saída pode ser suficiente.

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

Eu acho que;

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

A maneira mais simples de fazer isso é colocar um IF simples antes de fazer o SWITCH, e que IF teste sua condição para sair do loop .......... o mais simples possível

A breakpalavra-chave em C ++ apenas termina a iteração ou switchinstrução envolvente mais aninhada . Portanto, você não poderia sair do while (true)loop diretamente dentro da switchinstrução; no entanto, você pode usar o seguinte código, que considero um excelente padrão para esse tipo de problema:

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

    //...
    }
}

Se você precisava fazer algo quando msg->stateigual DONE(como executar uma rotina de limpeza), coloque esse código imediatamente após o forloop; ou seja, se você atualmente tem:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Em seguida, use:

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

    //...
    }
}

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

Me surpreende como isso é simples, considerando a profundidade das explicações ... Aqui está tudo que você precisa ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

RI MUITO!! Realmente! É tudo que você precisa! Uma variável 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**
}
}

Eu tive o mesmo problema e resolvi usando um flag.

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

Se bem me lembro da sintaxe C ++, você pode adicionar um rótulo às breakinstruções, assim como para goto. Portanto, o que você deseja seria facilmente escrito:

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
  }
}