Comment sortir d'une boucle depuis l'intérieur d'un interrupteur?

J'écris du code qui ressemble à ceci:

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

Y a-t-il un moyen direct de le faire?

Je sais que je peux utiliser un drapeau et rompre la boucle en mettant une interruption conditionnelle juste après le commutateur. Je veux juste savoir si C ++ a déjà une construction pour cela.

Prémisse

Le code suivant doit être considéré comme une mauvaise forme, quelle que soit la langue ou la fonctionnalité souhaitée:

while( true ) {
}

Arguments à l'appui

La while( true )boucle est de mauvaise forme car elle:

• Rompre le contrat implicite d'une boucle while.
  • La déclaration de boucle while doit explicitement indiquer la seule condition de sortie.
• Implique qu'il boucle pour toujours.
  • Le code dans la boucle doit être lu pour comprendre la clause de fin.
  • Les boucles qui se répètent indéfiniment empêchent l'utilisateur de terminer le programme à partir du programme.
• Est inefficace.
  • Il existe plusieurs conditions de terminaison de boucle, y compris la vérification de «vrai».
• Est sujet aux bugs.
  • Impossible de déterminer facilement où placer le code qui s'exécutera toujours à chaque itération.
• Conduit à un code inutilement complexe.
• Analyse automatique du code source.
  • Pour trouver des bogues, analyser la complexité du programme, vérifier la sécurité ou dériver automatiquement tout autre comportement de code source sans exécution de code, la spécification des conditions de rupture initiales permet aux algorithmes de déterminer des invariants utiles, améliorant ainsi les métriques d'analyse automatique du code source.
• Boucles infinies.
  • Si tout le monde utilise toujours while(true)des boucles qui ne sont pas infinies, nous perdons la capacité de communiquer de manière concise lorsque les boucles n'ont en fait aucune condition de terminaison. (On peut soutenir que cela s'est déjà produit, donc le point est sans objet.)

Alternative à "Aller à"

Le code suivant est de meilleure forme:

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

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

Avantages

Pas de drapeau. Non goto. Pas exception. Facile à changer. Facile à lire. Facile à réparer. En plus le code:

1. Isole la connaissance de la charge de travail de la boucle de la boucle elle-même.
2. Permet à quelqu'un qui gère le code d'étendre facilement la fonctionnalité.
3. Permet d'attribuer plusieurs conditions de fin en un seul endroit.
4. Sépare la clause de fin du code à exécuter.
5. Est plus sûr pour les centrales nucléaires. ;-)

Le deuxième point est important. Sans savoir comment fonctionne le code, si quelqu'un m'a demandé de faire en sorte que la boucle principale laisse aux autres threads (ou processus) un peu de temps CPU, deux solutions me viennent à l'esprit:

Option 1

Insérez facilement la pause:

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

Option 2

Remplacer l'exécution:

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

Ce code est plus simple (donc plus facile à lire) qu'une boucle avec un embarqué switch. La isValidStateméthode doit uniquement déterminer si la boucle doit continuer. La bête de somme de la méthode doit être abstraite dans la executeméthode, ce qui permet aux sous-classes de remplacer le comportement par défaut (une tâche difficile utilisant un switchet intégré goto).

Exemple Python

Comparez la réponse suivante (à une question Python) qui a été publiée sur StackOverflow:

1. Boucle pour toujours.
2. Demandez à l'utilisateur de saisir son choix.
3. Si l'entrée de l'utilisateur est «redémarrer», continuez à boucler indéfiniment.
4. Sinon, arrêtez de boucler pour toujours.
5. Fin.

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

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

print 'Break!' 

Contre:

1. Initialisez le choix de l'utilisateur.
2. Boucle tandis que le choix de l'utilisateur est le mot «redémarrer».
3. Demandez à l'utilisateur de saisir son choix.
4. Fin.

choice = 'restart';

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

print 'Break!'

Ici, il en while Truerésulte un code trompeur et trop complexe.

Vous pouvez utiliser goto.

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

   }
}
exit_loop: ;

Une autre solution consiste à utiliser le mot-clé continueen combinaison avec break, c'est-à-dire:

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

Utilisez l' continueinstruction pour terminer chaque étiquette de cas où vous voulez que la boucle continue et utilisez l' breakinstruction pour terminer les étiquettes de cas qui doivent terminer la boucle.

Bien sûr, cette solution ne fonctionne que s'il n'y a pas de code supplémentaire à exécuter après l'instruction switch.

Une manière élégante de faire ceci serait de mettre ceci dans une fonction:

int yourfunc() {

    while(true) {

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

    }
}

Facultativement (mais 'mauvaises pratiques'): comme déjà suggéré, vous pouvez utiliser un goto, ou lancer une exception à l'intérieur du commutateur.

AFAIK il n'y a pas de "double break" ou de construction similaire en C ++. Le plus proche serait un goto- qui, bien qu'il ait une mauvaise connotation pour son nom, existe dans la langue pour une raison - tant qu'il est utilisé avec prudence et parcimonie, c'est une option viable.

Vous pouvez mettre votre commutateur dans une fonction distincte comme celle-ci:

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

Même si vous n'aimez pas goto, n'utilisez pas d'exception pour quitter une boucle. L'exemple suivant montre à quel point cela pourrait être laid:

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

J'utiliserais gotocomme dans cette réponse. Dans ce cas, gotole code sera plus clair que toute autre option. J'espère que cette question vous sera utile.

Mais je pense que l'utilisation gotoest la seule option ici à cause de la chaîne while(true). Vous devriez envisager de refactoriser votre boucle. Je suppose la solution suivante:

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

Ou même ce qui suit:

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

Il n'y a pas de construction C ++ pour sortir de la boucle dans ce cas.

Utilisez un indicateur pour interrompre la boucle ou (le cas échéant) extrayez votre code dans une fonction et utilisez return.

Vous pourriez potentiellement utiliser goto, mais je préférerais définir un indicateur qui arrête la boucle. Puis sortez de l'interrupteur.

Pourquoi ne pas simplement corriger la condition dans votre boucle while, faisant disparaître le problème?

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

Non, C ++ n'a pas de construction pour cela, étant donné que le mot-clé "break" est déjà réservé pour quitter le bloc de commutation. Alternativement, un do.. while () avec un drapeau de sortie pourrait suffire.

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

Je pense;

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

Le moyen le plus simple de le faire est de mettre un simple IF avant de faire le SWITCH, et ce IF teste votre condition pour sortir de la boucle .......... aussi simple que possible

Le breakmot clé en C ++ termine uniquement l'itération ou l' switchinstruction englobante la plus imbriquée . Ainsi, vous ne pouviez pas sortir de la while (true)boucle directement dans l' switchinstruction; Cependant, vous pouvez utiliser le code suivant, qui, à mon avis, est un excellent modèle pour ce type de problème:

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

    //...
    }
}

Si vous aviez besoin de faire quelque chose lorsque msg->stateégal à égal DONE(comme exécuter une routine de nettoyage), placez ce code immédiatement après la forboucle; c'est-à-dire si vous avez actuellement:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Utilisez ensuite à la place:

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

    //...
    }
}

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

Je suis étonné de voir à quel point c'est simple compte tenu de la profondeur des explications ... Voici tout ce dont vous avez besoin ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

LOL !! Vraiment! C'est tout ce dont vous avez besoin! Une variable supplémentaire!

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

J'ai eu le même problème et je l'ai résolu à l'aide d'un drapeau.

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 je me souviens bien de la syntaxe C ++, vous pouvez ajouter une étiquette aux breakinstructions, comme pour goto. Donc, ce que vous voulez serait facilement écrit:

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