如何从交换机内部跳出循环？

Question

我正在编写一些如下所示的代码：

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        break; // **HERE, I want to break out of the loop itself**
    }
}

有没有直接的方法可以做到这一点？

我知道我可以使用一个标志，并通过在开关后面放置一个条件中断来中断循环。我只是想知道 C++ 是否已经有一些构造。

Answer 1

您可以使用goto。

while ( ... ) {
   switch( ... ) {
     case ...:
         goto exit_loop;

   }
}
exit_loop: ;

Answer 2

另一种解决方案是将关键字 continue 与 break 结合使用，即：

for (;;) {
    switch(msg->state) {
        case MSGTYPE:
            // code
            continue; // continue with loop
        case DONE:
            break;
    }
    break;
}

使用 continue 语句完成您想要的每个 case 标签。循环继续并使用 break 语句完成应终止循环的 case 标签。

当然，只有当 switch 语句之后没有额外的代码要执行时，此解决方案才有效。

Answer 3

前提

无论语言或所需的功能如何，以下代码都应被视为不良形式：

while( true ) {
}

支持参数

while( true ) 循环是不良形式，因为它：

• 破坏了 while 循环的隐含契约。
  • while 循环声明应明确声明仅退出条件。
• 意味着它会永远循环。
  • 必须阅读循环内的代码才能理解终止子句。
  • 永远重复的循环会阻止用户从程序内部终止程序。
• 效率低下。
  • 有多个循环终止条件，包括检查“true”。
• 容易出现错误。
  • 无法轻松确定将每次迭代始终执行的代码放置在何处。
• 导致不必要的复杂代码。
• 自动源代码分析。
  • 为了查找错误、程序复杂性分析、安全检查或在不执行代码的情况下自动派生任何其他源代码行为，指定初始中断条件允许算法确定有用的不变量，从而改进自动源代码分析指标。< /里>
• 无限循环。
  • 如果每个人都对非无限循环使用 while(true) ，那么当循环实际上没有终止条件时，我们就失去了简洁通信的能力。 （可以说，这已经发生了，所以这一点毫无意义。）

“Go To”的替代方案

以下代码是更好的形式：

while( isValidState() ) {
  execute();
}

bool isValidState() {
  return msg->state != DONE;
}

优点

无标志。没有转到。也不例外。易于改变。易于阅读。易于修复。另外，代码：

1. 将循环工作负载的信息与循环本身隔离开来。
2. 允许维护代码的人轻松扩展功能。
3. 允许在一处分配多个终止条件。
4. 将终止子句与要执行的代码分开。
5. 对于核电站来说更安全。 ;-)

第二点很重要。在不知道代码如何工作的情况下，如果有人要求我让主循环让其他线程（或进程）拥有一些 CPU 时间，我会想到两种解决方案：

选项#1

轻松插入暂停：

while( isValidState() ) {
  execute();
  sleep();
}

选项#2

覆盖执行：

void execute() {
  super->execute();
  sleep();
}

此代码比带有嵌入式开关的循环更简单（因此更容易阅读）。 isValidState 方法应仅确定循环是否应继续。该方法的主力应抽象为 execute 方法，该方法允许子类覆盖默认行为（使用嵌入式 switch 和 goto 是一项艰巨的任务代码>）。

Python 示例

对比 StackOverflow 上发布的以下答案（与 Python 问题）：

1. 永远循环。
2. 要求用户输入他们的选择。
3. 如果用户的输入是“重新启动”，则继续永远循环。
4. 否则，永远停止循环。
5. 结尾。

Code

while True: 
    choice = raw_input('What do you want? ')

    if choice == 'restart':
        continue
    else:
        break

print 'Break!' 

Versus：

1. 初始化用户的选择。
2. 当用户选择“重新启动”一词时循环。
3. 要求用户输入他们的选择。
4. 结尾。

Code

choice = 'restart';

while choice == 'restart': 
    choice = raw_input('What do you want? ')

print 'Break!'

在这里，while True 会产生误导性且过于复杂的代码。

Answer 4

一个巧妙的方法是将其放入一个函数中：

int yourfunc() {

    while(true) {

        switch(msg->state) {
        case MSGTYPE: // ... 
            break;
        // ... more stuff ...
        case DONE:
            return; 
        }

    }
}

可选（但“不好的做法”）：正如已经建议的，您可以使用 goto，或者在开关内抛出异常。

Answer 5

AFAIK 在 C++ 中没有“双重中断”或类似的构造。最接近的是 goto - 虽然它的名字有不好的含义，但它在语言中的存在是有原因的 - 只要小心谨慎地使用它，它就是一个可行的选择。

Answer 6

您可以将开关放入一个单独的函数中，如下所示：

bool myswitchfunction()
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        return false; // **HERE, I want to break out of the loop itself**
    }
    return true;
}

while(myswitchfunction())
    ;

Answer 7

即使您不喜欢 goto，也不要使用异常来退出循环。以下示例显示了它可能有多丑陋：

try {
  while ( ... ) {
    switch( ... ) {
      case ...:
        throw 777; // I'm afraid of goto
     }
  }
}
catch ( int )
{
}

我将使用 goto ，如 这个答案。在这种情况下，goto 将使代码比任何其他选项更清晰。我希望这个问题会有帮助。

但我认为使用 goto 是这里唯一的选择，因为字符串 while(true)。您应该考虑重构您的循环。我想采用以下解决方案：

bool end_loop = false;
while ( !end_loop ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        end_loop = true; break;
    }
}

或者甚至是以下解决方案：

while ( msg->state != DONE ) {
    switch( msg->state ) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
}

Answer 8

在这种情况下，没有用于跳出循环的 C++ 构造。

使用标志来中断循环或（如果适用）将代码提取到函数中并使用return。

Answer 9

不，C++ 没有这方面的构造，因为关键字“break”已经被保留用于退出 switch 块。或者，带有退出标志的 do..while() 就足够了。

do { 
    switch(option){
        case 1: ..; break;
        ...
        case n: .. ;break;
        default: flag = false; break;
    }
} while(flag);

Answer 10

您可能会使用 goto，但我更愿意设置一个停止循环的标志。然后断开开关。

Answer 11

为什么不直接修复 while 循环中的条件，从而使问题消失呢？

while(msg->state != DONE)
{
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        // We can't get here, but for completeness we list it.
        break; // **HERE, I want to break out of the loop itself**
    }
}

Answer 12

考虑到解释的深度，这让我感到惊讶......这就是你需要的一切......

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

哈哈！真的吗！这就是您所需要的！一个额外的变量！

Answer 13

我认为;

while(msg->state != mExit) 
{
    switch(msg->state) 
    {
      case MSGTYPE: // ...
         break;
      case DONE:
      //  .. 
      //  ..
      msg->state =mExit;
      break;
    }
}
if (msg->state ==mExit)
     msg->state =DONE;

Answer 14

我遇到了同样的问题并使用标志解决了。

bool flag = false;
while(true) {
    switch(msg->state) {
    case MSGTYPE: // ... 
        break;
    // ... more stuff ...
    case DONE:
        flag = true; // **HERE, I want to break out of the loop itself**
    }
    if(flag) break;
}

Answer 15

因为 switch 使用 break 从 switch 中退出（而不是从 while(1) 中退出），它需要 goto 语句：

while(1) {
    switch (*p) {
      case ' ':
        p++;
        break;
      case '\n':
        p++; *s=p; return(i);
      case '\0':
        *s=p; return(i);
      default:
        token[i]=p;
        i++;
        p++;
        goto ex1;
    };
  };
  ex1:

我无法将多个 case 添加到同一行，例如：

case ' ','\t':

它将是

case ' ': case '\t':

这就是原因也许这里使用的中断...

看起来最常见的情况应该放在列表的顶部，以使程序运行得更快。
它可能没有并行执行来搜索不同的案例。

标准 c 可能缺少一些有关此切换的方法：
https://blog.hackajob.co /better-c-switch-statements-for-a-range-of-values/
=>允许您在 switch 表达式中使用 <、>、<= 和 >= 运算符

我认为它应该是（如果 c 语言语法更改）如下：

switch (c) {
  case >= 5:
     ... op1
  endcase;
  case == 1:
  case == 3:
     ... op2
  endcase;
  default:
    ...
};

当 c 等于时执行 op2 1或3并且当c大于或等于5时op1被执行。
因为以类似的方式很容易进行等于或大于/小于的比较。

  while(1) {
    switch (c) {
      case >= 2:
         ... op1
      case <= 5:
         ... op2
      break;
      default:
        ...
    };
  };

这种情况下，op1 是在 c 大于 2 的情况下执行的，op2 是在 2<=c<=5 的情况下执行的，并且 break 从 while 循环中退出。

Answer 16

最简单的方法是在执行 SWITCH 之前放置一个简单的 IF ，然后 IF 测试退出循环的条件.......尽可能简单

Answer 17

C++ 中的 break 关键字仅终止最嵌套的封闭迭代或 switch 语句。因此，您无法直接在 switch 语句中跳出 while (true) 循环；但是您可以使用以下代码，我认为这是解决此类问题的绝佳模式：

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

如果您需要在 msg->state 等于 DONE 时执行某些操作（例如运行清理例程），然后将该代码立即放置在 for 循环之后；即如果您当前有：

while (true) {
    switch (msg->state) {
    case MSGTYPE:
        //... 
        break;

    //...

    case DONE:
        do_cleanup();
        break;
    }

    if (msg->state == DONE)
        break;

    msg = next_message();
}

则使用：

for (; msg->state != DONE; msg = next_message()) {
    switch (msg->state) {
    case MSGTYPE:
        //...
        break;

    //...
    }
}

assert(msg->state == DONE);
do_cleanup();

Answer 18

while(MyCondition) {
switch(msg->state) {
case MSGTYPE: // ... 
    break;
// ... more stuff ...
case DONE:
   MyCondition=false; // just add this code and you will be out of loop.
    break; // **HERE, you want to break out of the loop itself**
}
}

Answer 19

好吧，这是一个疯狂、不守规矩的本土 cpp 程序员和另一位程序员。优雅的程序员不愿意在循环体内使用终止条件，但我非常不同意。我用循环比普通程序员更多的事实来证明我的信念，因为我手动进行文本解析，而不是使用正则表达式。再加上我需要循环的其他情况。所以我理解循环内终止条件的需要。事实上，即使我只有一个条件，我可能更喜欢 while(true) 循环；为了在循环体内执行我的所有代码。例如：

while(true)
{
    if(condition)
    {
     // do something
     return;
    }

    // .... long body
}

这种格式允许人们立即看到循环终止时采取了什么操作。

无论如何，我将解释一下 BREAK_OUT_OF 关键字。它允许您从内部循环或 switch 语句中跳出外部循环或 switch 语句。该关键字设置为在 cpp 的下一版本（cpp 2026）中出现。但不用担心，现在您可以在原始 cpp 编译器中模拟它。以下是步骤。

步骤1：使用以下命令下载BREAK_OUT_OF关键字包：

#define BREAK_OUT_OF(ID) goto STATEMENT##ID
#define S_ID(ID)
#define DEF_S_ID(ID) STATEMENT##ID:

不要被命令中的goto语句所迷惑。这不是我们都讨厌的常规 goto 语句。它是变相的 jmp 语句。

第二步：现在你已经下载了兼容包；当您需要从内部语句中跳出外部语句时；你首先给它一个ID。您可以使用 S_ID 关键字来执行此操作。

while(true) S_ID(first_loop)

步骤 3：将 DEF_S_ID 关键字紧接在语句主体之后。请注意，在即将到来的 cpp 26 中，这将自动为我们完成。

while(true) S_ID(first_loop)
{
}DEF_S_ID(first_loop)

最后一步：使用 BREAK_OUT_OF 关键字从内循环中跳出外循环

while(true) S_ID(first_loop)
{
    switch(10) S_ID(1)
    {
     case 10: BREAK_OUT_OF(first_loop);
     case 0: BREAK_OUT_OF(1);
    }DEF_S_ID(1)
}DEF_S_ID(first_loop)

Answer 20

如果我记得很好的 C++ 语法，您可以向 break 语句添加一个标签，就像 goto 一样。所以你想要的很容易写成：

while(true) {
    switch(msg->state) {
    case MSGTYPE: // ...
        break;
    // ... more stuff ...
    case DONE:
        break outofloop; // **HERE, I want to break out of the loop itself**
    }
}

outofloop:
// rest of your code here

Answer 21

  while(true)
  {
    switch(x)
    {
     case 1:
     {
      break;
     }
    break;
   case 2:
    //some code here
   break;
  default:
  //some code here
  }
}