Come uscire da cicli annidati?

Question

Se utilizzo un'istruzione break, si interromperà solo il ciclo interno e sarà necessario utilizzare un flag per interrompere il ciclo esterno. Ma se ci sono molti cicli annidati, il codice non sembra buono.

C'è un altro modo per interrompere tutti i loop? (Si prega di non utilizzare 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 

Answer 1

Che dire:

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

Answer 2

avrete bisogno di una variabile booleana, se lo vuoi 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 lo vuoi meno leggibile è possibile unire la 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 un modo migliore si può invalidare il ciclo iniziale:

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

Answer 3

int i = 0, j= 0; 

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

si romperà entrambi i loop.

Answer 4

No, non rovinare il divertimento con uno break. Questo è l'ultimo utilizzo valido rimanente di goto :)

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

Un altro approccio per l'interruzione di un ciclo annidato consiste nel troncare entrambi i loop in una funzione separata e tornare da quella funzione quando si desidera uscire.

Riassunti - per uscire da cicli annidati:

1. uso goto
2. money
3. fattore out loop in funzione separata chiamate

non ha potuto resistere ad esclusione di xkcd qui :)

source

Goto's are considered harmful 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.

Answer 5

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

end: 

Answer 6

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

Answer 7

Un modo è quello di mettere tutti i cicli annidati in una funzione e tornare dal più ciclo interno in caso di un bisogno di uscire tutti i loop.

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

Answer 8

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

Answer 9

Penso goto risolverà il problema

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

end: 
stmt2 

Answer 10

Utilizzare questo saggio consiglio da squadra LLVM:

"Turn predicato Loops in funzioni predicato"

Vedi:

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

Answer 11

Se avete bisogno i valori di i e j, questo dovrebbe funzionare ma con meno prestazioni rispetto ad altri

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

Answer 12

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

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

Answer 13

Attenzione: Questa risposta dimostra una costruzione veramente oscuro.

Se si utilizza GCC, vedere this library. Come in PHP, break può accettare il numero di cicli nidificati che si desidera chiudere. È possibile scrivere qualcosa di simile:

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