Как вырваться из петли внутри переключателя?

Я пишу код, который выглядит так:

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 должно явно указывать единственное условие выхода.
• Подразумевается, что он зацикливается навсегда.
  • Код внутри цикла должен быть прочитан, чтобы понять завершающее предложение.
  • Циклы, которые повторяются бесконечно, не позволяют пользователю завершить программу изнутри программы.
• Неэффективно.
  • Есть несколько условий завершения цикла, включая проверку на «истину».
• Склонен к ошибкам.
  • Трудно определить, где разместить код, который всегда будет выполняться для каждой итерации.
• Приводит к излишне сложному коду.
• Автоматический анализ исходного кода.
  • Для поиска ошибок, анализа сложности программы, проверок безопасности или автоматического получения любого другого поведения исходного кода без выполнения кода указание начальных условий нарушения позволяет алгоритмам определять полезные инварианты, тем самым улучшая показатели автоматического анализа исходного кода.
• Бесконечные петли.
  • Если все всегда используют while(true)циклы for, которые не являются бесконечными, мы теряем способность кратко общаться, когда циклы фактически не имеют условия завершения. (Возможно, это уже произошло, поэтому вопрос спорный.)

Альтернатива "Перейти к"

Следующий код лучше:

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

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

Преимущества

Нет флага. Нет goto. Без исключения. Легко поменять. Легко читать. Легко исправить. Дополнительно код:

1. Изолирует информацию о рабочей нагрузке цикла от самого цикла.
2. Позволяет кому-то поддерживать код для простого расширения функциональности.
3. Позволяет назначать несколько условий завершения в одном месте.
4. Отделяет завершающее предложение от кода для выполнения.
5. Безопаснее для АЭС. ;-)

Второй момент важен. Не зная, как работает код, если кто-то попросит меня сделать так, чтобы основной цикл позволял другим потокам (или процессам) иметь некоторое процессорное время, на ум приходят два решения:

Опция 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оператор для завершения каждой метки case, где вы хотите, чтобы цикл продолжался, и используйте breakоператор для завершения меток case, которые должны завершать цикл.

Конечно, это решение работает только в том случае, если нет дополнительного кода для выполнения после оператора switch.

Изящный способ сделать это - поместить это в функцию:

int yourfunc() {

    while(true) {

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

    }
}

Необязательно (но «плохие практики»): как уже предлагалось, вы можете использовать goto или выбросить исключение внутри переключателя.

Насколько я знаю, в С ++ нет «двойного разрыва» или аналогичной конструкции. Ближайшим из них был бы 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.

Нет, в C ++ нет конструкции для этого, поскольку ключевое слово break уже зарезервировано для выхода из блока переключения. В качестве альтернативы может быть достаточно do..time () с флагом выхода.

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

Потенциально вы можете использовать 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**
    }
}

Меня поражает, насколько это просто, учитывая глубину объяснений ... Вот все, что вам нужно ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

РЖУНИМАГУ!! В самом деле! Это все, что вам нужно! Одна дополнительная переменная!

Думаю;

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

Самый простой способ сделать это - поставить простой IF перед выполнением SWITCH, и этот IF проверяет ваше условие для выхода из цикла .......... настолько просто, насколько это возможно

breakКлючевое слово в C ++ только завершает наиболее вложенные ограждающие итерации или 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();

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операторам, как для 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
  }
}