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

我正在写一些看起来像这样的代码：

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

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

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

前提

不管语言或所需功能如何，以下代码都应视为错误的形式：

while( true ) {
}

支持论点

该while( true )循环形式不佳，因为它：

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

替代“转到”

以下代码是更好的形式：

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

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

优点

没有标志。没有goto。没有例外。容易改变。易于阅读。易于修复。另外的代码：

1. 从循环本身中分离出有关循环工作量的知识。
2. 允许维护代码的人员轻松扩展功能。
3. 允许在一个位置分配多个终止条件。
4. 将终止子句与要执行的代码分开。
5. 对于核电厂更安全。;-)

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

选项1

立即插入暂停：

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

选项＃2

覆盖执行：

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

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

Python范例

将以下答案（针对Python问题）与StackOverflow上发布的内容进行对比：

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

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

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

print 'Break!' 

与：

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

choice = 'restart';

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

print 'Break!'

在这里，while True导致误导和过于复杂的代码。

您可以使用goto。

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

   }
}
exit_loop: ;

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

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

使用该continue语句在希望循环继续的地方完成每个案例标签，并使用break语句完成应终止循环的案例标签。

当然，只有在switch语句之后没有其他代码要执行的情况下，此解决方案才有效。

一种简单的方法是将其放入函数中：

int yourfunc() {

    while(true) {

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

    }
}

可选（但“不良做法”）：如已经建议的那样，您可以使用goto或在开关内引发异常。

AFAIK在C ++中没有“双破”或类似的构造。最接近的将是goto-尽管名称含义不正确，但由于某种原因在语言中存在-只要谨慎且谨慎地使用它，这是一个可行的选择。

您可以将开关置于这样的单独函数中：

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())
    ;

即使您不喜欢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 ...
}

在这种情况下，没有C ++构造可以打破循环。

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

您可能会使用goto，但我希望设置一个标志来停止循环。然后断开开关。

为什么不只在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**
    }
}

不，C ++没有为此构造，因为已经为退出开关块保留了关键字“ break”。或者，带有退出标志的do..while（）可能就足够了。

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

我认为;

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

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

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

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();

令我感到惊讶的是，如此深入的解释如此简单...这就是您所需要的...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

大声笑！！真！这就是您所需要的！一个额外的变量！

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

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

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

如果我还记得C ++语法，则可break以为语句添加标签，就像for一样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

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