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

Question

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

如果是这样，你会怎样做呢？您还可以控制 break 退出多少个循环吗？

Answer 1

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

Answer 2

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

Answer 3

只是使用 lambda 添加一个明确的答案：

  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，但我认为它非常有用。

Answer 4

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

当然，这会带来另一个论点，即是否应该从函数末尾以外的任何地方显式返回。

Answer 5

break 将仅退出包含它的最内层循环。

您可以使用goto来打破任意数量的循环。

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

使用break函数是否正确[...]？

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

Answer 6

这个怎么样？

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

Answer 7

使用 goto 和标签来跳出嵌套循环的代码示例：

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

Answer 8

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

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

}

Answer 9

我知道这是一个老话题，但我觉得这确实需要说，而且没有其他地方可以说。对于这里的每个人，请使用goto。我刚刚使用过它。

与几乎所有事物一样，goto 并不是 100% 要么/异或“坏”或“好”。我想说的是，至少有两种用途，如果您对它们使用 goto - 并且不将其用于其他任何用途 - 您不仅应该 100% 没问题，而且您的程序将比没有它更具可读性，因为它使您的意图更加清晰（有很多方法可以避免它，但我发现它们都更加笨拙）：

1. 打破嵌套循环，以及
2. 错误处理（即跳转到清理例程）函数结束以返回失​​败代码并释放内存。）。

不要教条地接受诸如“马马虎虎”之类的规则，而要理解为什么要表达这种观点，并遵循“为什么”，而不是情绪。不知道这一点也给我带来了很多麻烦，以至于我想说，教条地称事物为“邪恶”可能比事物本身更有害。最坏的情况是，你只是得到了糟糕的代码——然后只要你听说要小心谨慎，你就知道你没有正确使用它，但如果你为了满足教条主义而折磨自己，我会说那更糟糕。

为什么“goto”被称为“邪恶”是因为你永远不应该用它来代替普通的 if、fors 和 while。为什么呢？尝试一下，尝试一直使用“goto”代替普通的控制逻辑语句，然后尝试用控制逻辑再次编写相同的代码，并告诉我哪一个看起来更好、更容易理解，哪一个看起来更混乱。就这样吧。 （奖励：现在尝试向仅限 goto 的代码添加一个新功能。）这就是为什么它是“邪恶”的，并且围绕“邪恶”有适当的范围限定。用它来弥补 C 的“break”命令的缺点不是一个有问题的用法，只要你从代码中明确你的 goto 应该做什么完成（例如使用“nestedBreak”之类的标签）。打破嵌套循环是非常自然的。

（或者更简单地说：使用 goto 来跳出循环。我想说这更好。不要使用 goto 创建循环。< em>那是“邪恶”。）

你怎么知道你是否教条主义？如果遵循“xyz 是邪恶的”规则导致您的代码不太易于理解，因为您扭曲自己试图绕过它（例如在每个循环上添加额外的条件或一些标志变量，或类似的其他技巧），那么你很可能是教条主义的。

学习良好的思维习惯比良好的编码习惯更重要，这是无可替代的。前者先于后者，而一旦前者被采用，后者往往也会随之而来。然而，问题是，我经常发现后者解释得不够。太多人只是简单地说“这很糟糕”和“这需要更多思考”，而没有说思考什么、关于思考什么以及为什么 。这是一个很大的耻辱。

（FWIW，在 C++ 中，仍然存在打破嵌套循环的需要，但不再需要错误代码：在这种情况下，始终使用异常来处理错误代码，永远不要返回它们，除非它会如此频繁地导致异常抛出和捕获将导致性能问题，例如在高要求服务器代码的紧密循环中，也许[有些人可能会说“异常”应该“很少使用”，但这是考虑不周的教条主义的另一部分：不，至少根据我在打破这一教条后的经验，我发现它们使事情变得更加清晰 - 只是不要滥用它们来做除错误处理之外的事情，例如将它们用作有效的控制流；与“goto”一样。如果您全部使用它们并且仅用于错误处理，那就是它们的用途。]。）

Answer 10

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

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

Answer 11

我不确定这是否值得，但是您可以使用一些简单的宏来模拟 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);
}

Answer 12

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

Answer 13

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

要模拟 break/continue，您需要：

Break

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

Continue

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

Answer 14

break 语句终止最近的封闭 do、for、switch 或 的执行它出现在 >while 语句中。控制权传递到终止语句后面的语句。

来自 msdn。

Answer 15

我的建议是使用检查变量来打破所需的循环。结果代码可能不太令人愉快。
您可以使用预处理器来进行所需的底层破坏。这种方法可以隐藏丑陋的代码和额外的复杂性。
例如，我创建了自定义中断机制，如下所示：

想要的代码：

for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
        for (int k = 0; k < 100; k++) {
            //do something
            if (desiredCondition) {
                breakToLevel = 0;
            }
            if (breakToLevel < 3) {
                break;
            }
        }
        if (breakToLevel < 2) {
            break;
        }
    }
    if (breakToLevel < 1) {
        break;
    }
}

定义的宏：

#define BREAK_TO(L) breakToLevel = (L); 
#define CHECK_BREAK(L) if (breakToLevel < (L)) break; 

和结果：

for (int i = 0; i < 100; i++) {
    for (int j = 0; j < 100; j++) {
        for (int k = 0; k < 100; k++) {
            //do something
            if (desiredCondition) {
                BREAK_TO(0)
            }
            CHECK_BREAK(3)
        }
        CHECK_BREAK(2)
    }
    CHECK_BREAK(1)
}

Answer 16

您必须使用在循环之前设置为 false 的布尔值来解决此问题，如果要中断，则在循环中设置为 true，再加上嵌套循环之后的条件中断，检查布尔值是否设置为 true如果是的话就打破。

Answer 17

我知道这是旧帖子。但我会建议一个更合乎逻辑且更简单的答案。

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

Answer 18

只需一个 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; 所有循环。

Answer 19

最优雅的方式是使用异常。

异常是指遇到不正常的情况，这种情况不仅可以是太糟糕的情况，也可以是太好的情况。

例如，您正在寻找具有 3 个嵌套 for 循环的 3d 数组中的元素。 正常情况是“当前不是我正在寻找的”。 异常情况是“当前就是这样”。

请记住错误和异常之间的区别。异常不一定是错误，它可能是一个好消息。

Answer 20

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

如果您必须同时跳出多个循环，那么无论如何它通常都是一个例外。