Come rompere i loop annidati?

Se uso breakun'istruzione, interromperà solo il ciclo interno e ho bisogno di usare un flag per interrompere il ciclo esterno. Ma se ci sono molti cicli annidati, il codice non avrà un bell'aspetto.

C'è un altro modo per interrompere tutti i loop? (Per favore, non usare 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

Uso:

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

No, non rovinare il divertimento con un file break. Questo è l'ultimo uso valido rimanente di goto;)

In caso contrario, è possibile utilizzare i flag per rompere i loop nidificati profondi.

Un altro approccio per interrompere un ciclo annidato consiste nel fattorizzare entrambi i cicli in una funzione separata e tornare da quella funzione quando si desidera uscire.

Riepilogo: per rompere i loop annidati:

1. uso goto
2. usa le bandiere
3. scomporre i cicli in chiamate di funzioni separate

Non ho potuto resistere a includere xkcd qui :)

fonte

I Goto sono considerati dannosi ma come molte persone nei commenti suggeriscono che non è necessario. Se usato con giudizio può essere un ottimo strumento. Qualsiasi cosa usata con moderazione è divertente.

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

Un modo è mettere tutti i loop annidati in una funzione e tornare dal loop più interno in caso di necessità di rompere tutti i loop.

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

Penso gotoche risolverà il problema

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

end:
stmt2 

Avrai bisogno di una variabile booleana, se vuoi che sia leggibile:

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

Se vuoi che sia meno leggibile puoi unirti alla valutazione booleana:

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

Come modo definitivo puoi invalidare il ciclo iniziale:

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

Usa questo saggio consiglio del team LLVM:

"Trasforma i loop predicato in funzioni predicato"

Vedere:

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

Attenzione: questa risposta mostra una costruzione davvero oscura.

Se stai usando GCC, controlla questa libreria . Come in PHP, breakpuò accettare il numero di cicli annidati da cui si desidera uscire. Puoi scrivere qualcosa del genere:

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:

Se hai bisogno dei valori di i e j, dovrebbe funzionare ma con prestazioni inferiori rispetto ad altri

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

Spezzerà entrambi gli anelli.

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