Come uscire da un loop dall'interno di un interruttore?

Sto scrivendo del codice che assomiglia a questo:

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

C'è un modo diretto per farlo?

So di poter usare un flag e interrompere il ciclo inserendo un'interruzione condizionale subito dopo lo switch. Voglio solo sapere se C ++ ha già qualche costrutto per questo.

Premessa

Il codice seguente dovrebbe essere considerato una cattiva forma, indipendentemente dalla lingua o dalla funzionalità desiderata:

while( true ) {
}

Argomenti di supporto

Il while( true )loop è di scarsa qualità perché:

• Rompe il contratto implicito di un ciclo while.
  • La dichiarazione del ciclo while dovrebbe indicare esplicitamente l' unica condizione di uscita.
• Implica che funzioni per sempre.
  • Il codice all'interno del ciclo deve essere letto per comprendere la clausola di chiusura.
  • I cicli che si ripetono per sempre impediscono all'utente di terminare il programma dall'interno del programma.
• È inefficiente.
  • Esistono più condizioni di terminazione del ciclo, incluso il controllo di "true".
• È soggetto a insetti.
  • Non è possibile determinare facilmente dove inserire il codice che verrà sempre eseguito per ogni iterazione.
• Porta a codice inutilmente complesso.
• Analisi automatica del codice sorgente.
  • Per trovare bug, analisi della complessità del programma, controlli di sicurezza o derivare automaticamente qualsiasi altro comportamento del codice sorgente senza l'esecuzione del codice, la specifica delle condizioni di interruzione iniziali consente agli algoritmi di determinare invarianti utili, migliorando così le metriche di analisi automatica del codice sorgente.
• Loop infiniti.
  • Se tutti usano sempre while(true)cicli for che non sono infiniti, perdiamo la capacità di comunicare in modo conciso quando i cicli non hanno effettivamente una condizione di terminazione. (Probabilmente, questo è già successo, quindi il punto è discutibile.)

Alternativa a "Vai a"

Il codice seguente è una forma migliore:

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

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

vantaggi

Nessuna bandiera. No goto. Nessuna eccezione. Facile da cambiare. Facile da leggere. Facile da riparare. Inoltre il codice:

1. Isola la conoscenza del carico di lavoro del loop dal loop stesso.
2. Consente a qualcuno che mantiene il codice di estendere facilmente la funzionalità.
3. Consente di assegnare più condizioni di terminazione in un'unica posizione.
4. Separa la clausola di terminazione dal codice da eseguire.
5. È più sicuro per le centrali nucleari. ;-)

Il secondo punto è importante. Senza sapere come funziona il codice, se qualcuno mi chiedesse di fare in modo che il ciclo principale lasci che altri thread (o processi) abbiano un po 'di tempo CPU, vengono in mente due soluzioni:

Opzione 1

Inserisci subito la pausa:

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

Opzione 2

Esegui override:

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

Questo codice è più semplice (quindi più facile da leggere) di un ciclo con un file switch. Il isValidStatemetodo dovrebbe determinare solo se il ciclo deve continuare. Il cavallo di battaglia del metodo dovrebbe essere astratto nel executemetodo, che consente alle sottoclassi di sovrascrivere il comportamento predefinito (un compito difficile utilizzando un switche incorporato goto).

Esempio di Python

Confronta la seguente risposta (a una domanda di Python) che è stata pubblicata su StackOverflow:

1. Loop per sempre.
2. Chiedere all'utente di inserire la propria scelta.
3. Se l'input dell'utente è "riavvia", continua il ciclo per sempre.
4. Altrimenti, interrompi il ciclo per sempre.
5. Fine.

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

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

print 'Break!' 

Contro:

1. Inizializza la scelta dell'utente.
2. Esegui il ciclo mentre la scelta dell'utente è la parola "riavvia".
3. Chiedere all'utente di inserire la propria scelta.
4. Fine.

choice = 'restart';

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

print 'Break!'

Qui, si while Truetraduce in codice fuorviante ed eccessivamente complesso.

Puoi usare goto.

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

   }
}
exit_loop: ;

Una soluzione alternativa consiste nell'usare la parola chiave continuein combinazione con break, ad esempio:

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

Utilizzare l' continueistruzione per terminare ciascuna etichetta di caso in cui si desidera che il ciclo continui e utilizzare l' breakistruzione per terminare le etichette di caso che dovrebbero terminare il ciclo.

Ovviamente questa soluzione funziona solo se non c'è codice aggiuntivo da eseguire dopo l'istruzione switch.

Un modo accurato per farlo sarebbe metterlo in una funzione:

int yourfunc() {

    while(true) {

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

    }
}

Facoltativamente (ma "cattive pratiche"): come già suggerito potresti usare un goto o lanciare un'eccezione all'interno dello switch.

AFAIK non esiste una "doppia interruzione" o un costrutto simile in C ++. Il più vicino sarebbe un goto- che, sebbene abbia una cattiva connotazione al suo nome, esiste nella lingua per un motivo - purché sia ​​usato con attenzione e con parsimonia, è un'opzione praticabile.

Potresti inserire il tuo interruttore in una funzione separata come questa:

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())
    ;

Anche se non ti piace goto, non utilizzare un'eccezione per uscire da un ciclo. Il seguente esempio mostra quanto potrebbe essere brutto:

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

Userei gotocome in questa risposta. In questo caso il gotocodice sarà più chiaro rispetto a qualsiasi altra opzione. Spero che questa domanda sia utile.

Ma penso che l'uso gotosia l'unica opzione qui a causa della stringa while(true). Dovresti considerare il refactoring del tuo loop. Suppongo la seguente soluzione:

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

O anche il seguente:

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

Non esiste un costrutto C ++ per uscire dal ciclo in questo caso.

Utilizzare un flag per interrompere il ciclo o (se appropriato) estrarre il codice in una funzione e utilizzare return.

Potresti potenzialmente usare goto, ma preferirei impostare un flag che interrompa il ciclo. Quindi rompi l'interruttore.

Perché non correggere semplicemente la condizione nel ciclo while, facendo scomparire il problema?

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 ++ non ha un costrutto per questo, dato che la parola chiave "break" è già riservata per uscire dal blocco switch. In alternativa, un do..while () con un flag di uscita potrebbe essere sufficiente.

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

Penso;

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

Il modo più semplice per farlo è mettere un semplice IF prima di fare lo SWITCH, e IF testare la tua condizione per uscire dal ciclo .......... il più semplice possibile

La breakparola chiave in C ++ termina solo l'iterazione o l' switchistruzione di inclusione più annidata . Pertanto, non è possibile uscire dal while (true)ciclo direttamente all'interno switchdell'istruzione; tuttavia potresti usare il seguente codice, che penso sia un modello eccellente per questo tipo di problema:

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

    //...
    }
}

Se hai bisogno di fare qualcosa quando è msg->stateuguale DONE(come eseguire una routine di pulizia), inserisci quel codice immediatamente dopo il forciclo; cioè se attualmente hai:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Quindi usa invece:

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

    //...
    }
}

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

Mi stupisce quanto sia semplice considerando la profondità delle spiegazioni ... Ecco tutto ciò di cui hai bisogno ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL !! Veramente! È tutto ciò di cui hai bisogno! Una variabile in più!

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

Ho avuto lo stesso problema e l'ho risolto usando una bandiera.

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 ricordo bene la sintassi C ++, puoi aggiungere un'etichetta alle breakistruzioni, proprio come per goto. Quindi quello che vuoi sarebbe facilmente scritto:

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