จะแยกลูปที่ซ้อนกันได้อย่างไร?

ถ้าฉันใช้breakคำสั่งมันจะทำลายวงในเท่านั้นและฉันต้องใช้แฟล็กเพื่อทำลายวงนอก แต่ถ้ามีลูปที่ซ้อนกันมากโค้ดจะดูไม่ดี

มีวิธีอื่นในการทำลายลูปทั้งหมดหรือไม่? (กรุณาอย่าใช้goto stmt)

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; j++) {
       if(condition) {
            // both of the loops need to break and control will go to stmt2
       }
   }

}

stmt2

ใช้:

if (condition) {
    i = j = 1000;
    break;
}

ไม่อย่าทำให้เสียความสนุกด้วยไฟล์break. นี่คือการใช้งานที่ถูกต้องล่าสุดที่เหลืออยู่ของgoto;)

หากไม่เป็นเช่นนั้นคุณสามารถใช้แฟล็กเพื่อแยกลูปที่ซ้อนกันลึก ๆ

อีกวิธีหนึ่งในการแยกออกจากลูปที่ซ้อนกันคือการแยกทั้งสองลูปออกเป็นฟังก์ชันแยกกันและกลับจากฟังก์ชันนั้นเมื่อคุณต้องการออก

สรุป - เพื่อแยกออกจากลูปที่ซ้อนกัน:

1. ใช้ goto
2. ใช้ธง
3. แยกลูปออกเป็นการเรียกฟังก์ชันแยกกัน

ไม่สามารถต้านทานการรวม xkcd ไว้ที่นี่ :)

แหล่งที่มา

Goto ถือว่าเป็นอันตรายแต่หลายคนในความคิดเห็นแนะนำว่าไม่จำเป็นต้องเป็น หากใช้อย่างรอบคอบอาจเป็นเครื่องมือที่ยอดเยี่ยม อะไรก็ตามที่ใช้ในการกลั่นกรองเป็นเรื่องสนุก

bool stop = false;
for (int i = 0; (i < 1000) && !stop; i++)
{
    for (int j = 0; (j < 1000) && !stop; j++)
    {
        if (condition)
            stop = true;
    }
}

วิธีหนึ่งคือใส่ลูปที่ซ้อนกันทั้งหมดลงในฟังก์ชันและกลับจากวงในสุดในกรณีที่จำเป็นต้องแยกออกจากลูปทั้งหมด

function() 
{    
  for(int i=0; i<1000; i++)
  {
   for(int j=0; j<1000;j++)
   {
      if (condition)
        return;
   }
  }    
}

ฉันคิดว่าgotoจะแก้ปัญหาได้

for(int i = 0; i < 1000; i++) {
    for(int j = 0; j < 1000; j++) {
        if (condition) {
            goto end;
        }
    }
}

end:
stmt2 

 

คุณจะต้องมีตัวแปรบูลีนหากคุณต้องการให้อ่านได้:

bool broke = false;
for(int i = 0; i < 1000; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      broke = true;
      break;
    }
  }
  if (broke)
    break;
}

หากคุณต้องการให้อ่านน้อยลงคุณสามารถเข้าร่วมการประเมินบูลีนได้:

bool broke = false;
for(int i = 0; i < 1000 && !broke; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      broke = true;
      break;
    }
  }
}

วิธีที่ดีที่สุดคุณสามารถยกเลิกการวนรอบเริ่มต้นได้:

for(int i = 0; i < size; i++) {
  for(int j = 0; j < 1000; i++) {
    if (condition) {
      i = size;
      break;
    }
  }
}

ใช้คำแนะนำที่ชาญฉลาดจากทีม LLVM:

"เปลี่ยนเพรดิเคตลูปเป็นฟังก์ชันเพรดิเคต"

ดู:

http://llvm.org/docs/CodingStandards.html#turn-predicate-loops-into-predicate-functions

ข้อควรระวัง: คำตอบนี้แสดงโครงสร้างที่คลุมเครืออย่างแท้จริง

หากคุณใช้ GCC โปรดดูไลบรารีนี้ เช่นเดียวกับใน PHP breakสามารถยอมรับจำนวนลูปที่ซ้อนกันที่คุณต้องการออกได้ คุณสามารถเขียนสิ่งนี้:

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; j++) {
       if(condition) {
            // break two nested enclosing loops
            break(2);
       }
   }
}

for(int i = 0; i < 1000; i++) {
   for(int j = 0; j < 1000; i++) {
       if(condition) {
            goto end;
   }
} 

end:

หากคุณต้องการค่า i และ j สิ่งนี้ควรใช้งานได้ แต่มีประสิทธิภาพน้อยกว่าค่าอื่น ๆ

for(i;i< 1000; i++){    
    for(j; j< 1000; j++){
        if(condition)
            break;
    }
    if(condition) //the same condition
        break;
}

วิธีการที่แตกต่างกันคือการ refactor รหัสจากสองสำหรับลูปเป็นสำหรับลูปและหนึ่งลูปแบบแมนนวล วิธีนี้จะใช้การแบ่งในลูปแมนนวลกับวงนอก ฉันเคยใช้สิ่งนี้ครั้งหนึ่งในการกำจัดเกาส์ - จอร์แดนซึ่งต้องใช้ลูปซ้อนกันสามครั้งในการประมวลผล

for (int i = 0; i < 1000; i++)
{
    int j = 0;

MANUAL_LOOP:;

    if (j < 1000)
    {
       if (condition)
       {
           break;
       }

       j++;
       goto MANUAL_LOOP;
    }
}

ฉันสังเกตว่าคำถามคือ "มีวิธีอื่นในการทำลายลูปทั้งหมดหรือไม่" ฉันไม่เห็นคุณสมบัติใด ๆ แต่มันไม่ใช่gotoโดยเฉพาะ OP ไม่ได้ขอวิธีที่ดี แล้วเราจะlongjmpออกจากวงในได้อย่างไร? :-)

#include <stdio.h>
#include <setjmp.h>

int main(int argc, char* argv[]) {
  int counter = 0;
  jmp_buf look_ma_no_goto;
  if (!setjmp(look_ma_no_goto)) {
    for (int i = 0; i < 1000; i++) {
      for (int j = 0; j < 1000; j++) {
        if (i == 500 && j == 500) {
          longjmp(look_ma_no_goto, 1);
        }
        counter++;
      }
    }
  }
  printf("counter=%d\n", counter);
}

setjmpฟังก์ชั่นผลตอบแทนครั้งที่สอง ในครั้งแรกจะคืนค่า 0 และโปรแกรมเรียกใช้งานที่ซ้อนกันสำหรับลูป จากนั้นเมื่อทั้งสองiและjเป็น 500 มันจะดำเนินการlongjmpซึ่งทำให้setjmpกลับมาอีกครั้งด้วยค่า 1 โดยข้ามไปที่ลูป

ไม่เพียง แต่จะlongjmpนำคุณออกจากลูปที่ซ้อนกันเท่านั้น แต่ยังทำงานร่วมกับฟังก์ชันที่ซ้อนกันได้อีกด้วย!

int i = 0, j= 0;

for(i;i< 1000; i++){    
    for(j; j< 1000; j++){
        if(condition){
            i = j = 1001;
            break;
        }
    }
}

จะแตกทั้งลูป.

for(int i = 0; i < 1000; i++) {
    for(int j = 0; j < 1000; i++) {
       if(condition) {
          func(para1, para2...);
          return;
       }
    }
}

func(para1, para2...) {
    stmt2;
}

i = 0;

do
{
  for (int j = 0; j < 1000; j++) // by the way, your code uses i++ here!
  {
     if (condition)
     {
       break;
     }
  }

  ++i;

} while ((i < 1000) && !condition);