จะแยกวงออกจากสวิตช์ภายในได้อย่างไร?

ฉันกำลังเขียนโค้ดที่มีลักษณะดังนี้:

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 loop
  • ประกาศในขณะที่ห่วงอย่างชัดเจนควรระบุเพียงเงื่อนไขทางออก
• หมายความว่ามันวนซ้ำตลอดไป
  • ต้องอ่านรหัสภายในลูปเพื่อทำความเข้าใจกับประโยคยุติ
  • ลูปที่ทำซ้ำตลอดไปจะป้องกันไม่ให้ผู้ใช้ยุติโปรแกรมจากภายในโปรแกรม
• ไม่มีประสิทธิภาพ
  • มีเงื่อนไขการสิ้นสุดลูปหลายเงื่อนไขรวมถึงการตรวจสอบ "จริง"
• มีแนวโน้มที่จะเกิดข้อบกพร่อง
  • ไม่สามารถระบุได้อย่างง่ายดายว่าจะวางโค้ดไว้ที่ใดซึ่งจะรันสำหรับการวนซ้ำแต่ละครั้ง
• นำไปสู่รหัสที่ซับซ้อนโดยไม่จำเป็น
• การวิเคราะห์ซอร์สโค้ดอัตโนมัติ
  • หากต้องการค้นหาจุดบกพร่องการวิเคราะห์ความซับซ้อนของโปรแกรมการตรวจสอบความปลอดภัยหรือหาลักษณะการทำงานของซอร์สโค้ดอื่น ๆ โดยอัตโนมัติโดยไม่มีการเรียกใช้โค้ดการระบุเงื่อนไขการทำลายเริ่มต้นช่วยให้อัลกอริทึมสามารถกำหนดค่าคงที่ที่เป็นประโยชน์ได้ซึ่งจะช่วยปรับปรุงเมตริกการวิเคราะห์ซอร์สโค้ดอัตโนมัติ
• ลูปไม่มีที่สิ้นสุด
  • หากทุกคนมักใช้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คำสั่งเพื่อจบเลเบลเคสที่ควรยุติลูป

แน่นอนวิธีนี้ใช้ได้เฉพาะในกรณีที่ไม่มีรหัสเพิ่มเติมให้ดำเนินการหลังจากคำสั่งสวิตช์

วิธีที่เรียบร้อยในการทำเช่นนี้คือการนำสิ่งนี้ไปใช้ในฟังก์ชัน:

int yourfunc() {

    while(true) {

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

    }
}

ทางเลือก (แต่เป็น 'แนวทางปฏิบัติที่ไม่ดี'): ตามที่แนะนำไปแล้วว่าคุณสามารถใช้ goto หรือโยนข้อยกเว้นภายในสวิตช์

AFAIK ไม่มี "double break" หรือโครงสร้างที่คล้ายกันใน 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 loop ของคุณทำให้ปัญหาหายไป

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;

วิธีที่ง่ายที่สุดคือใส่ 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();

มันทำให้ฉันประหลาดใจว่ามันง่ายแค่ไหนเมื่อพิจารณาถึงความลึกของคำอธิบาย ... นี่คือสิ่งที่คุณต้องการ ...

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