Làm thế nào để thoát khỏi vòng lặp từ bên trong một công tắc?

Tôi đang viết một số mã trông giống như sau:

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

Có cách nào trực tiếp để làm điều đó?

Tôi biết mình có thể sử dụng cờ và ngắt khỏi vòng lặp bằng cách đặt dấu ngắt có điều kiện ngay sau nút chuyển. Tôi chỉ muốn biết nếu C ++ có một số cấu trúc cho điều này đã.

Tiền đề

Mã sau đây sẽ được coi là hình thức xấu, bất kể ngôn ngữ hoặc chức năng mong muốn:

while( true ) {
}

Lập luận hỗ trợ

Các while( true )vòng lặp là hình thức nghèo vì nó:

• Phá vỡ hợp đồng ngụ ý của một vòng lặp trong khi.
  • Khai báo vòng lặp while phải nêu rõ điều kiện thoát duy nhất .
• Ngụ ý rằng nó lặp lại mãi mãi.
  • Mã trong vòng lặp phải được đọc để hiểu mệnh đề kết thúc.
  • Các vòng lặp lặp lại mãi mãi ngăn người dùng chấm dứt chương trình từ bên trong chương trình.
• Không hiệu quả.
  • Có nhiều điều kiện kết thúc vòng lặp, bao gồm cả việc kiểm tra "true".
• Dễ bị lỗi.
  • Không thể dễ dàng xác định nơi đặt mã sẽ luôn thực thi cho mỗi lần lặp.
• Dẫn đến mã phức tạp không cần thiết.
• Phân tích mã nguồn tự động.
  • Để tìm lỗi, phân tích độ phức tạp của chương trình, kiểm tra bảo mật hoặc tự động lấy ra bất kỳ hành vi mã nguồn nào khác mà không cần thực thi mã, việc chỉ định (các) điều kiện phá vỡ ban đầu cho phép các thuật toán xác định các bất biến hữu ích, do đó cải thiện các chỉ số phân tích mã nguồn tự động.
• Vòng lặp vô hạn.
  • Nếu mọi người luôn sử dụng while(true)vòng lặp for không phải là vô hạn, chúng ta sẽ mất khả năng giao tiếp chính xác khi các vòng lặp thực sự không có điều kiện kết thúc. (Có thể cho rằng, điều này đã xảy ra rồi, vì vậy vấn đề là tranh luận.)

Thay thế cho "Đi tới"

Đoạn mã sau là dạng tốt hơn:

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

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

Ưu điểm

Không có cờ. Không goto. Không có ngoại lệ. Dễ dàng thay đổi. Dễ đọc. Dễ dàng sửa chữa. Ngoài ra, mã:

1. Cô lập kiến ​​thức về khối lượng công việc của vòng lặp khỏi chính vòng lặp.
2. Cho phép ai đó duy trì mã dễ dàng mở rộng chức năng.
3. Cho phép nhiều điều kiện kết thúc được gán ở một nơi.
4. Tách mệnh đề kết thúc khỏi mã để thực thi.
5. An toàn hơn cho các nhà máy Điện hạt nhân. ;-)

Điểm thứ hai là quan trọng. Nếu không biết mã hoạt động như thế nào, nếu ai đó yêu cầu tôi tạo vòng lặp chính để các luồng (hoặc quy trình) khác có một chút thời gian CPU, bạn sẽ nghĩ đến hai giải pháp:

Lựa chọn 1

Dễ dàng chèn tạm dừng:

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

Lựa chọn 2

Ghi đè thực thi:

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

Mã này đơn giản hơn (do đó dễ đọc hơn) so với một vòng lặp có nhúng switch. Các isValidStatephương pháp duy nhất nên xác định xem vòng lặp nên tiếp tục. Workhorse của phương thức nên được trừu tượng hóa thành executephương thức, điều này cho phép các lớp con ghi đè hành vi mặc định (một nhiệm vụ khó khăn khi sử dụng nhúng switchvà goto).

Ví dụ Python

Đối chiếu câu trả lời sau (cho một câu hỏi Python) đã được đăng trên StackOverflow:

1. Vòng lặp mãi mãi.
2. Yêu cầu người dùng nhập lựa chọn của họ.
3. Nếu đầu vào của người dùng là 'khởi động lại', hãy tiếp tục lặp lại mãi mãi.
4. Nếu không, dừng lặp lại mãi mãi.
5. Kết thúc.

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

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

print 'Break!' 

Đấu với:

1. Khởi tạo sự lựa chọn của người dùng.
2. Vòng lặp trong khi lựa chọn của người dùng là từ 'khởi động lại'.
3. Yêu cầu người dùng nhập lựa chọn của họ.
4. Kết thúc.

choice = 'restart';

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

print 'Break!'

Ở đây, while Truedẫn đến mã sai lệch và quá phức tạp.

Bạn có thể sử dụng goto.

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

   }
}
exit_loop: ;

Một giải pháp thay thế là sử dụng từ khóa continuekết hợp với break, tức là:

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

Sử dụng continuecâu lệnh để kết thúc mỗi nhãn trường hợp mà bạn muốn vòng lặp tiếp tục và sử dụng breakcâu lệnh để kết thúc các nhãn trường hợp kết thúc vòng lặp.

Tất nhiên giải pháp này chỉ hoạt động nếu không có mã bổ sung nào để thực thi sau câu lệnh switch.

Một cách tốt nhất để làm điều này là đặt nó vào một hàm:

int yourfunc() {

    while(true) {

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

    }
}

Tùy chọn (nhưng 'phương pháp không tốt'): như đã đề xuất, bạn có thể sử dụng goto hoặc ném một ngoại lệ bên trong công tắc.

AFAIK không có "ngắt đôi" hoặc cấu trúc tương tự trong C ++. Cái gần nhất sẽ là a goto- mặc dù nó có hàm ý xấu đối với tên của nó, nhưng tồn tại trong ngôn ngữ là có lý do - miễn là nó được sử dụng cẩn thận và tiết kiệm, đó là một lựa chọn khả thi.

Bạn có thể đặt công tắc của mình vào một chức năng riêng biệt như sau:

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

Ngay cả khi bạn không thích goto, không sử dụng ngoại lệ để thoát khỏi vòng lặp. Mẫu sau đây cho thấy nó có thể xấu như thế nào:

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

Tôi sẽ sử dụng gotonhư trong câu trả lời này . Trong trường hợp gotonày sẽ làm cho mã rõ ràng hơn sau đó bất kỳ tùy chọn nào khác. Tôi hy vọng rằng đây câu hỏi sẽ rất hữu ích.

Nhưng tôi nghĩ rằng sử dụng gotolà lựa chọn duy nhất ở đây vì chuỗi while(true). Bạn nên xem xét việc cấu trúc lại vòng lặp của mình. Tôi cho rằng giải pháp sau:

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

Hoặc thậm chí như sau:

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

Không có cấu trúc C ++ nào để thoát ra khỏi vòng lặp trong trường hợp này.

Sử dụng cờ để ngắt vòng lặp hoặc (nếu thích hợp) trích xuất mã của bạn vào một hàm và sử dụng return.

Bạn có thể sử dụng goto, nhưng tôi muốn đặt cờ dừng vòng lặp. Sau đó thoát ra khỏi công tắc.

Tại sao không chỉ sửa điều kiện trong vòng lặp while của bạn, làm cho sự cố biến mất?

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

Không, C ++ không có cấu trúc cho điều này, vì từ khóa "break" đã được dành riêng để thoát khỏi khối chuyển đổi. Ngoài ra, một do.. while () với cờ thoát có thể là đủ.

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

Tôi nghĩ;

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

Cách đơn giản nhất để làm điều đó là đặt một IF đơn giản trước khi bạn thực hiện CHUYỂN ĐỔI và IF kiểm tra điều kiện của bạn để thoát khỏi vòng lặp .......... càng đơn giản càng tốt

Các breaktừ khóa trong C ++ chỉ chấm dứt lặp kèm theo nhiều nhất lồng nhau hoặc switchtuyên bố. Do đó, bạn không thể thoát ra khỏi while (true)vòng lặp trực tiếp trong switchcâu lệnh; tuy nhiên, bạn có thể sử dụng mã sau, mà tôi nghĩ là một mẫu tuyệt vời cho loại vấn đề này:

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

    //...
    }
}

Nếu bạn cần làm điều gì đó khi msg->statebằng DONE(chẳng hạn như chạy một quy trình dọn dẹp), thì hãy đặt mã đó ngay sau forvòng lặp; tức là nếu bạn hiện có:

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

    //...

    case DONE:
        do_cleanup();
        break;
    }

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

    msg = next_message();
}

Sau đó sử dụng thay thế:

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

    //...
    }
}

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

Tôi ngạc nhiên là điều này đơn giản như thế nào khi xem xét chiều sâu của các lời giải thích ... Đây là tất cả những gì bạn cần ...

bool imLoopin = true;

while(imLoopin) {

    switch(msg->state) {

        case MSGTYPE: // ... 
            break;

        // ... more stuff ...

        case DONE:
            imLoopin = false;
            break;

    }

}

CƯỜI LỚN!! Có thật không! Đó là tất cả những gì bạn cần! Thêm một biến!

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

Tôi gặp vấn đề tương tự và đã giải quyết bằng cờ.

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

Nếu tôi nhớ tốt cú pháp C ++, bạn có thể thêm nhãn vào các breakcâu lệnh, giống như for goto. Vì vậy, những gì bạn muốn sẽ được viết dễ dàng:

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