我可以使用break退出多个嵌套的“ for”循环吗？

是否可以使用该break函数退出几个嵌套for循环？

如果是这样，您将如何进行？您还可以控制break出口有多少个循环吗？

AFAIK，C ++不像Java和其他语言那样支持命名循环。您可以使用goto或创建使用的标志值。在每个循环结束时，检查标志值。如果将其设置为true，则可以中断该迭代。

不，不要用破坏它break。这是使用的最后一个据点goto。

只是使用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
        }
      }
    }();
  }

当然，这种模式有一定的局限性，显然只有C ++ 11，但我认为它非常有用。

打破嵌套循环的另一种方法是将两个循环分解为一个单独的函数，并return在需要退出时从该函数中分解出来。

当然，这提出了另一个论点，即是否应该return从函数的末尾以外的任何地方显式地进行。

break将仅退出包含它的最里面的循环。

您可以使用goto中断任何数量的循环。

当然goto通常被认为是有害的。

使用break函数是否合适[...]？

使用break和goto会使推理程序的正确性变得更加困难。有关此问题的讨论，请参见此处： Dijkstra并不疯狂。

尽管已经提出了这个问题，但我认为一种好的方法是执行以下操作：

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

}

这个怎么样？

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

一个使用goto和标签打破嵌套循环的代码示例：

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

打破几个嵌套循环的一种好方法是将代码重构为一个函数：

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对于打破嵌套循环可能非常有帮助

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

的break语句终止最近的封闭的执行do，for，switch，或while在其出现的语句。控制权传递给终止语句之后的语句。

来自msdn。

我确实认为goto在这种情况下a 是有效的：

要模拟break/ continue，您需要：

打破

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

继续

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

其他语言（例如PHP）接受break参数（即break 2;）来指定要突破的嵌套循环级别的数量，而C ++则不行。您必须使用在循环之前设置为false的布尔值（如果要中断，在循环中设置为true），以及在嵌套循环后使用条件中断，检查布尔值是否设置为true，来解决此问题。如果是的话就打破。

我知道这是旧帖子。但是我建议一个合理且简单的答案。

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

只需一个bool变量即可中断任意数量的循环，如下所示：

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

在这段代码中，我们break;所有的循环。

我不确定是否值得，但是您可以使用一些简单的宏来模拟Java的命名循环：

#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

用法示例：

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

另一个例子：

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

  }

您可以使用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

如果必须一次跳出几个循环，无论如何通常都是一个例外。

打破for循环对我来说有点奇怪，因为for循环的语义通常表明它将执行指定的次数。但是，这在所有情况下都还不错。如果您要在集合中搜索某些东西，并且想在找到之后打破它，这很有用。但是，在C ++中不可能脱离嵌套循环。通过使用带标记的中断可以使用其他语言。您可以使用标签和goto，但这可能会在晚上使您胃灼热。似乎是最好的选择。