Як вирватися з петлі зсередини вимикача?

Я пишу код, який виглядає приблизно так:

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

Звичайно, це рішення працює лише в тому випадку, якщо після оператора переключення немає додаткового коду для виконання.

Акуратним способом зробити це було б ввести це у функцію:

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" вже зарезервоване для виходу з блоку комутації. Як альтернатива може бути достатньо до.. 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;

Найпростіший спосіб зробити це - поставити простий IF перед тим, як зробити SWITCH, і якщо ЯК перевірити ваш стан для виходу з циклу .......... так просто, як це може бути

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

Мене дивує, як просто це враховує глибину пояснень ... Ось усе, що вам потрібно ...

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висловлювань, як і для 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
  }
}