C++: romper el bucle principal

Question

estoy preparando algo de código:

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555) 
      break; 
    } 

    for(int c = 2001; c <= 3000; c++) //loop c 
    { 
     . 
     . 
     . 
    } 
} 

Quiero romper el bucle principal (variable de bucle int a) mediante una instrucción break; en el b bucle (variable de bucle int b).

¿Cómo puedo hacerlo?

Answer 1

recomiendo refactorización su código en una función. A continuación, puede simplemente return de esa función en lugar de utilizar break:

void myFunc() 
{ 
    for(int a = 1; a <= 100; a++) //loop a (main loop) 
    { 
     for(int b = 1000; b <= 2000; b++) //loop b 
     { 
      if(b == 1555) // Logic is just an example, 
       return; // since it will always return 
     } 

     . 
     . 
     . 
    } 
} 

Este - o tal vez incluso una refactorización más complicado de su código - debe prestarse a una solución limpia, elegante. Por otra parte, si lo que desea una solución rápida se puede utilizar una variable de condición:

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    bool cond = false; 

    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555){ 
      cond = true; 
      break; 
     } 
    } 

    if (cond) break; 

    . 
    . 
    . 
} 

---

Otros han sugerido el uso de goto. Si bien esa es otra solución rápida, recomiendo encarecidamente que no lo haga, especialmente si está trabajando en un entorno riguroso en el que el código será revisado por pares y utilizado durante años en el futuro.

En mi opinión el enfoque goto es un poco más difícil de mantener que una refactorización función/retorno, sobre todo más adelante, cuando otra persona realiza cambios en el código. Además, deberá justificar el goto con cualquier otra persona del equipo que se tropiece con el código.

Answer 2

Utilice un goto.

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555) 
      goto loopDone; 
    } 

    for(int c = 2001; c <= 3000; c++) //loop c 
    { 
     . 
     . 
     . 
    } 
} 
loopDone: 

Answer 3

for(int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    for(int b = 1000; b <= 2000; b++) //loop b 
    { 
     if(b == 1555) 
      goto end; 
    } 

    for(int c = 2001; c <= 3000; c++) //loop c 
    { 
     . 
     . 
     . 
    } 
} 
end: 

Answer 4

La única forma de salir de dos de tales bucles a la vez es una goto o una throw o una return, y throw y return pueden no ser apropiados (en particular throw, si la condición ISN' t excepcional). Alternativamente, puede establecer algún tipo de condición (bool breakout;) y seguir rompiendo si es verdad.

Answer 5

Usar este tipo de patrón

for(int a = 1; a <= 100; a++) 
{ 
    int breakMain = 0; 
    for(int b = 1000; b <= 2000; b++) 
    { 
     if(b == 1555) 
     { 
      breakMain = 1; 
      break; 
     } 
    } 

    if(breakMain) 
     break; 

    for(int c = 2001; c <= 3000; c++) 
    { 
     . 
     . 
     . 
    } 
} 

Answer 6

1. Utilice un goto:

   for(int a = 1; a <= 100; a++) //loop a (main loop) 
   { 
       for(int b = 1000; b <= 2000; b++) //loop b 
       { 
        if(b == 1555) 
         goto done; 
       } 
       for(int c = 2001; c <= 3000; c++) //loop c 
       { 
        . 
        . 
        . 
       } 
   } 
   done: 
   

2. establecer un valor centinela probado por cada bucle:

   bool sentinel = true ; 
   for(int a = 1; a <= 100 && sentinel ; a++) //loop a (main loop) 
   { 
       for(int b = 1000; b <= 2000 && sentinel; b++) //loop b 
       { 
        if(b == 1555) 
         sentinel = false; 
       } 
       for(int c = 2001; c <= 3000 && sentinel; c++) //loop c 
       { 
        . 
        . 
        . 
       } 
   } 
   

Answer 7

Si es apropiado, se puede hacer una función que está contenido son el a loop, y use return.

public void bigLoop() 
{ 
    for(int a = 1; a <= 100; a++) 
    { 
     for(int b = 1000; b <= 2000; b++) 
     { 
      if(b == 1555) 
       return; 
     } 

     for(int c = 2001; c <= 3000; c++) 
     { 
      . 
      . 
      . 
     } 
    } 
}//bigLoop 

Answer 8

Una estrategia simple es poner el lazo en una función independiente y hacer una vuelta en el punto seleccionado:

void func() 
{ 
    for(int a = 1; a <= 100; a++) //loop a (main loop) 
    { 
     for(int b = 1000; b <= 2000; b++) //loop b 
     { 
      if(b == 1555) 
       return; 
     } 

     for(int c = 2001; c <= 3000; c++) //loop c 
     { 
      . 
      . 
      . 
     } 
    } 
} 

Cualquier tipo de resultado también puede ser devuelto con un valor de retorno, o con un parámetro de referencia para la función.

Answer 9

Haga cualquiera de estas cuatro cosas: use goto, use throw, use una bandera o refactor.

Muchos estarán en desacuerdo con using goto, pero sometimes es una solución limpia. (La mayoría de las veces, no lo es, pero existe por una razón). Sin embargo, creo que el uso de goto garantiza un refactor.

La segunda solución es to throw alguna excepción especial y luego la captura justo fuera del bucle principal. Esto es un abuso del sistema de excepción y básicamente un peor goto; utilice un goto en lugar de esto.

La tercera solución sería usar a flag de some sort. Esto es básicamente un "seguro" goto, pero algunos podrían argumentar que es un poco más feo. (Especialmente con niveles múltiples. Aunque en tal caso su preocupación es qué tan feo es su código)

La solución que recomendaría es refactor. Lo que sea que estés haciendo, es demasiado. Debería mover los bucles internos a una función y llamar a esa función. Volver al bucle principal es simplemente un retorno de esa función. (En otras palabras, "Mi trabajo está hecho")

Answer 10

La forma ideal sería volver a factorizar el código para que ya no necesite una estructura de bucle anidado tan complicada. Dependiendo de cómo se vea el resto del código, los bucles b y c pueden ser candidatos para convertirse en funciones individuales, si no todo el bucle a.

Dado que parece que los bucles b y c iteran sobre rangos adyacentes, ¿por qué no combinarlos y reducir un poco la anidación del bucle?

for (int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    int count = 1000; 
    while (count <= 3000) // combined loops 'b' and 'c' 
    { 
     if (count <= 2000) 
     { 
      // Old loop 'b' code 
      if (b == 1555) 
       goto fullbreak; 
     } 
     else 
     { 
      // Old loop 'c' code 
      ... 
     } 
     count++; 
    } 
} 
fullbreak: 

También puede utilizar una variable de estado en lugar del goto. Si desea salir del antiguo bucle b pero aún procesar el antiguo bucle c, simplemente configure count = 2001 dentro del antiguo código de bucle b.

Lo ideal sería al menos ser capaz de volver a este factor a algo más parecido a

for (int a = 1; a <= 100; a++) //loop a (main loop) 
{ 
    if (process_inner_loop(pass, required, args)) 
     break; 
} 

donde la función process_inner_loop envuelve sus dos bucles originales y devuelve un valor no nulo si desea salir de el bucle adjunto. Ahora, en lugar de usar goto o variables de condición, simplemente puede return 1;.

Answer 11

\ (◕ ◡ ◕)/

[]() { 
    for(int a = 1; a <= 100; a++) //loop a (main loop) 
    { 
     for(int b = 1000; b <= 2000; b++) //loop b 
     { 
      if(b == 1555) 
       return; 
     } 

     for(int c = 2001; c <= 3000; c++) //loop c 
     { 
      . 
      . 
      . 
     } 
    } 
}();