¿Puedo usar break para salir de múltiples bucles 'for' anidados?

¿Es posible usar la breakfunción para salir de varios forbucles anidados ?

Si es así, ¿cómo harías para hacer esto? ¿Puedes controlar también cuántos bucles breaksalen?

AFAIK, C ++ no admite bucles de nombres, como lo hacen Java y otros lenguajes. Puede usar un goto o crear un valor de marca que use. Al final de cada ciclo, verifique el valor del indicador. Si se establece en verdadero, puede salir de esa iteración.

No, no lo estropees con un break. Este es el último bastión restante para el uso de goto.

Solo para agregar una respuesta explícita usando lambdas:

  for (int i = 0; i < n1; ++i) {
    [&] {
      for (int j = 0; j < n2; ++j) {
        for (int k = 0; k < n3; ++k) {
          return; // yay we're breaking out of 2 loops here
        }
      }
    }();
  }

Por supuesto, este patrón tiene ciertas limitaciones y obviamente solo C ++ 11, pero creo que es bastante útil.

Otro enfoque para salir de un bucle anidado es factorizar ambos bucles en una función separada, y returndesde esa función cuando desee salir.

Por supuesto, esto trae a colación el otro argumento de si alguna vez debería explícitamente returndesde una función en cualquier lugar que no sea al final.

break saldrá solo del bucle más interno que lo contiene.

Puede usar goto para salir de cualquier número de bucles.

Por supuesto, ir a menudo se considera perjudicial .

¿Es apropiado usar la función de interrupción [...]?

Usar break y goto puede hacer que sea más difícil razonar sobre la corrección de un programa. Vea aquí para una discusión sobre esto: Dijkstra no estaba loco .

Aunque esta respuesta ya se presentó, creo que un buen enfoque es hacer lo siguiente:

for(unsigned int z = 0; z < z_max; z++)
{
    bool gotoMainLoop = false;
    for(unsigned int y = 0; y < y_max && !gotoMainLoop; y++)
    {
        for(unsigned int x = 0; x < x_max && !gotoMainLoop; x++)
        {
                          //do your stuff
                          if(condition)
                            gotoMainLoop = true;
        }
    }

}

¿Qué tal esto?

for(unsigned int i=0; i < 50; i++)
{
    for(unsigned int j=0; j < 50; j++)
    {
        for(unsigned int k=0; k < 50; k++)
        {
            //Some statement
            if (condition)
            {
                j=50;
                k=50;
            }
        }
    }
}

Un ejemplo de código con gotouna etiqueta para salir de un bucle anidado:

for (;;)
  for (;;)
    goto theEnd;
theEnd:

Una buena manera de salir de varios bucles anidados es refactorizar su código en una función:

void foo()
{
    for(unsigned int i=0; i < 50; i++)
    {
        for(unsigned int j=0; j < 50; j++)
        {
            for(unsigned int k=0; k < 50; k++)
            {
                // If condition is true
                return;
            }
        }
    }
}

Goto puede ser muy útil para romper bucles anidados

for (i = 0; i < 1000; i++) {
    for (j = 0; j < 1000; j++) {
        for (k = 0; k < 1000; k++) {
             for (l = 0; l < 1000; l++){
                ....
                if (condition)
                    goto break_me_here;
                ....
            }
        }
    }
}

break_me_here:
// Statements to be executed after code breaks at if condition

El breakcomunicado termina la ejecución de la más cercana de cerramiento do, for, switch, o whiledeclaración en la que aparece. El control pasa a la declaración que sigue a la declaración terminada.

de msdn .

Creo que un goto es válido en esta circunstancia:

Para simular un break/continue , querrías:

Rotura

for ( ;  ;  ) {
    for ( ;  ;  ) {
        /*Code here*/
        if (condition) {
            goto theEnd;
        }
    }
}
theEnd:

Seguir

for ( ;  ; ) {
    for ( ;  ;  ) {
        /*Code here*/
        if (condition) {
            i++;
            goto multiCont;
        }
    }
    multiCont:
}

Otros lenguajes, como PHP, aceptan un parámetro para la interrupción (es decir, la interrupción 2;) para especificar la cantidad de niveles de bucle anidados de los que desea salir, pero C ++ no lo hace. Tendrá que resolverlo usando un booleano que establezca en falso antes del ciclo, establezca en verdadero en el ciclo si desea romper, más un corte condicional después del ciclo anidado, verificando si el booleano se estableció en verdadero y romper si es así.

Sé que esta es una publicación antigua. Pero sugeriría una respuesta un poco lógica y más simple.

for(unsigned int i=0; i < 50; i++)
    {
        for(unsigned int j=0; j < conditionj; j++)
        {
            for(unsigned int k=0; k< conditionk ; k++)
            {
                // If condition is true

                j= conditionj;
               break;
            }
        }
    }

Divida cualquier número de bucles por una sola boolvariable, vea a continuación:

bool check = true;

for (unsigned int i = 0; i < 50; i++)
{
    for (unsigned int j = 0; j < 50; j++)
    {
        for (unsigned int k = 0; k < 50; k++)
        {
            //Some statement
            if (condition)
            {
                check = false;
                break;
            }
        }
        if (!check)
        {
            break;
        }
    }
    if (!check)
    {
        break;
    }
}

En este código tenemos break;todos los bucles.

No estoy seguro de si vale la pena, pero puede emular los bucles con nombre de Java con algunas macros simples:

#define LOOP_NAME(name) \
    if ([[maybe_unused]] constexpr bool _namedloop_InvalidBreakOrContinue = false) \
    { \
        [[maybe_unused]] CAT(_namedloop_break_,name): break; \
        [[maybe_unused]] CAT(_namedloop_continue_,name): continue; \
    } \
    else

#define BREAK(name) goto CAT(_namedloop_break_,name)
#define CONTINUE(name) goto CAT(_namedloop_continue_,name)

#define CAT(x,y) CAT_(x,y)
#define CAT_(x,y) x##y

Ejemplo de uso:

#include <iostream>

int main()
{
    // Prints:
    // 0 0
    // 0 1
    // 0 2
    // 1 0
    // 1 1

    for (int i = 0; i < 3; i++) LOOP_NAME(foo)
    {
        for (int j = 0; j < 3; j++)
        {
            std::cout << i << ' ' << j << '\n';
            if (i == 1 && j == 1)
                BREAK(foo);
        }
    }
}

Otro ejemplo:

#include <iostream>

int main()
{
    // Prints: 
    // 0
    // 1
    // 0
    // 1
    // 0
    // 1

    int count = 3;
    do LOOP_NAME(foo)
    {
        for (int j = 0; j < 3; j++)
        {
            std::cout << ' ' << j << '\n';
            if (j == 1)
                CONTINUE(foo);
        }
    }
    while(count-- > 1);
}

  while (i<n) {
    bool shouldBreakOuter = false;
    for (int j=i + 1; j<n; ++j) {
      if (someCondition) {
          shouldBreakOuter = true;
      }
    }

    if (shouldBreakOuter == true)
      break;

  }

Puedes usar try ... catch.

try {
    for(int i=0; i<10; ++i) {
        for(int j=0; j<10; ++j) {
            if(i*j == 42)
                throw 0; // this is something like "break 2"
        }
    }
}
catch(int e) {} // just do nothing
// just continue with other code

Si tiene que salir de varios bucles a la vez, a menudo es una excepción.

Romper un bucle for es un poco extraño para mí, ya que la semántica de un bucle for generalmente indica que se ejecutará un número específico de veces. Sin embargo, no es malo en todos los casos; si está buscando algo en una colección y quiere romperlo después de encontrarlo, es útil. Sin embargo, la ruptura de bucles anidados no es posible en C ++; es en otros idiomas mediante el uso de un descanso etiquetado. Puede usar una etiqueta y un goto, pero eso podría provocarle acidez estomacal por la noche ... Sin embargo, parece la mejor opción.