Comment sortir des boucles imbriquées?

Si j'utilise une breakinstruction, cela ne cassera que la boucle interne et je dois utiliser un indicateur pour rompre la boucle externe. Mais s'il y a de nombreuses boucles imbriquées, le code n'aura pas l'air bien.

Existe-t-il un autre moyen de rompre toutes les boucles? (Veuillez ne pas utiliser goto stmt.)

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; j++) {
       if(condition) {
            // both of the loops need to break and control will go to stmt2
       }
   }

}

stmt2

Utilisation:

if (condition) {
    i = j = 1000;
    break;
}

Non, ne gâchez pas le plaisir avec un break. Ceci est la dernière utilisation valide restante de goto;)

Sinon, vous pouvez utiliser des indicateurs pour sortir des boucles imbriquées profondes.

Une autre approche pour sortir d'une boucle imbriquée consiste à factoriser les deux boucles dans une fonction distincte et à revenir de cette fonction lorsque vous souhaitez quitter.

Résumé - pour sortir des boucles imbriquées:

1. utilisation goto
2. utiliser des drapeaux
3. factoriser les boucles en appels de fonction séparés

Je n'ai pas pu résister à l'inclusion de xkcd ici :)

la source

Les Goto sont considérés comme nuisibles, mais comme de nombreuses personnes dans les commentaires le suggèrent S'il est utilisé judicieusement, il peut être un excellent outil. Tout ce qui est utilisé avec modération est amusant.

bool stop = false;
for (int i = 0; (i < 1000) && !stop; i++)
{
    for (int j = 0; (j < 1000) && !stop; j++)
    {
        if (condition)
            stop = true;
    }
}

Une façon est de mettre toutes les boucles imbriquées dans une fonction et de revenir de la boucle la plus interne en cas de besoin de sortir de toutes les boucles.

function() 
{    
  for(int i=0; i<1000; i++)
  {
   for(int j=0; j<1000;j++)
   {
      if (condition)
        return;
   }
  }    
}

Je pense que ça gotorésoudra le problème

for(int i = 0; i < 1000; i++) {
    for(int j = 0; j < 1000; i++) {
        if (condition) {
            goto end;
        }
    }
}

end:
stmt2 

Vous aurez besoin d'une variable booléenne, si vous voulez qu'elle soit lisible:

bool broke = false;
for(int i = 0; i < 1000; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      broke = true;
      break;
    }
  }
  if (broke)
    break;
}

Si vous le souhaitez moins lisible, vous pouvez rejoindre l'évaluation booléenne:

bool broke = false;
for(int i = 0; i < 1000 && !broke; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      broke = true;
      break;
    }
  }
}

Comme moyen ultime, vous pouvez invalider la boucle initiale:

for(int i = 0; i < size; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      i = size;
      break;
    }
  }
}

Utilisez ce conseil avisé de l'équipe LLVM:

"Transformez les boucles de prédicat en fonctions de prédicat"

Voir:

http://llvm.org/docs/CodingStandards.html#turn-predicate-loops-into-predicate-functions

Attention: cette réponse montre une construction vraiment obscure.

Si vous utilisez GCC, consultez cette bibliothèque . Comme en PHP, breakpeut accepter le nombre de boucles imbriquées que vous souhaitez quitter. Vous pouvez écrire quelque chose comme ceci:

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; j++) {
       if(condition) {
            // break two nested enclosing loops
            break(2);
       }
   }
}

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; i++) {
       if(condition) {
            goto end;
   }
} 

end:

Si vous avez besoin des valeurs de i et j, cela devrait fonctionner mais avec moins de performances que les autres

for(i;i< 1000; i++){    
    for(j; j< 1000; j++){
        if(condition)
            break;
    }
    if(condition) //the same condition
        break;
}

int i = 0, j= 0;

for(i;i< 1000; i++){    
    for(j; j< 1000; j++){
        if(condition){
            i = j = 1001;
            break;
        }
    }
}

Va casser les deux boucles.

for(int i = 0; i < 1000; i++) {
    for(int j = 0; j < 1000; i++) {
       if(condition) {
          func(para1, para2...);
          return;
       }
    }
}

func(para1, para2...) {
    stmt2;
}

i = 0;

do
{
  for (int j = 0; j < 1000; j++) // by the way, your code uses i++ here!
  {
     if (condition)
     {
       break;
     }
  }

  ++i;

} while ((i < 1000) && !condition);