อะไรคือวิธีที่ดีกว่าในการหลีกเลี่ยงสิ่งที่ต้องทำในขณะที่ (0); แฮ็คใน C ++?

เมื่อโฟลว์โค้ดเป็นดังนี้:

if(check())
{
  ...
  ...
  if(check())
  {
    ...
    ...
    if(check())
    {
      ...
      ...
    }
  }
}

ฉันได้เห็นงานนี้ทั่วเพื่อหลีกเลี่ยงการไหลของรหัสยุ่งข้างต้น:

do {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

มีวิธีใดบ้างที่ดีกว่าที่จะหลีกเลี่ยงวิธีนี้เพื่อหลีกเลี่ยงการแฮ็กเพื่อให้เป็นโค้ดระดับสูงขึ้น (ระดับอุตสาหกรรม)

ข้อเสนอแนะใด ๆ ที่อยู่นอกกรอบยินดีต้อนรับ!

ถือว่าเป็นแนวปฏิบัติที่ยอมรับได้เพื่อแยกการตัดสินใจเหล่านี้ในฟังก์ชั่นและใช้returns แทนbreaks ในขณะที่การตรวจสอบทั้งหมดเหล่านี้สอดคล้องกับระดับนามธรรมของฟังก์ชั่นมันเป็นวิธีการที่ค่อนข้างตรรกะ

ตัวอย่างเช่น:

void foo(...)
{
   if (!condition)
   {
      return;
   }
   ...
   if (!other condition)
   {
      return;
   }
   ...
   if (!another condition)
   {
      return;
   }
   ... 
   if (!yet another condition)
   {
      return;
   }
   ...
   // Some unconditional stuff       
}

มีหลายครั้งที่การใช้gotoคำตอบที่ถูกต้องคืออย่างน้อยสำหรับคนที่ไม่เชื่อในศาสนาว่า " gotoไม่สามารถเป็นคำตอบได้ไม่ว่าคำถามจะเป็นอย่างไร" - และนี่เป็นหนึ่งในกรณีเหล่านั้น

รหัสนี้จะใช้สับของdo { ... } while(0);เพื่อวัตถุประสงค์ของการแต่งเนื้อแต่งตัวเป็นgoto breakหากคุณกำลังจะใช้gotoให้เปิดเกี่ยวกับมัน ไม่มีจุดในการทำให้รหัส HARDER อ่าน

สถานการณ์เฉพาะคือเมื่อคุณมีโค้ดจำนวนมากที่มีเงื่อนไขค่อนข้างซับซ้อน:

void func()
{
   setup of lots of stuff
   ...
   if (condition)
   {
      ... 
      ...
      if (!other condition)
      {
          ...
          if (another condition)
          {
              ... 
              if (yet another condition)
              {
                  ...
                  if (...)
                     ... 
              }
          }
      }
  .... 

  }
  finish up. 
}

มันสามารถทำให้ชัดเจนว่ารหัสถูกต้องโดยไม่มีตรรกะที่ซับซ้อนเช่นนั้น

void func()
{
   setup of lots of stuff
   ...
   if (!condition)
   {
      goto finish;
   }
   ... 
   ...
   if (other condition)
   {
      goto finish;
   }
   ...
   if (!another condition)
   {
      goto finish;
   }
   ... 
   if (!yet another condition)
   {
      goto finish;
   }
   ... 
   .... 
   if (...)
         ...    // No need to use goto here. 
 finish:
   finish up. 
}

แก้ไข: เพื่อชี้แจงฉันไม่เคยเสนอการใช้gotoเป็นวิธีแก้ปัญหาทั่วไป แต่มีบางกรณีที่gotoเป็นทางออกที่ดีกว่าโซลูชันอื่น ๆ

ลองนึกภาพตัวอย่างว่าเรากำลังรวบรวมข้อมูลบางอย่างและเงื่อนไขที่แตกต่างกันที่กำลังทดสอบคือ "นี่คือจุดสิ้นสุดของข้อมูลที่รวบรวม" - ซึ่งขึ้นอยู่กับเครื่องหมาย "ต่อ / จบ" บางประเภทที่แตกต่างกันไปขึ้นอยู่กับตำแหน่ง คุณอยู่ในกระแสข้อมูล

ตอนนี้เมื่อเราทำเสร็จแล้วเราต้องบันทึกข้อมูลลงในไฟล์

และใช่มักจะมีโซลูชันอื่น ๆ ที่สามารถให้โซลูชันที่สมเหตุสมผล แต่ไม่เสมอไป

คุณสามารถใช้รูปแบบการต่อเนื่องอย่างง่ายกับboolตัวแปร:

bool goOn;
if ((goOn = check0())) {
    ...
}
if (goOn && (goOn = check1())) {
    ...
}
if (goOn && (goOn = check2())) {
    ...
}
if (goOn && (goOn = check3())) {
    ...
}

ห่วงโซ่ของการดำเนินการนี้จะหยุดทันทีที่ผลตอบแทนcheckN falseจะไม่มีการcheck...()โทรเพิ่มเติมเนื่องจากการลัดวงจรของ&&ผู้ควบคุมเครื่อง นอกจากนี้การเพิ่มประสิทธิภาพคอมไพเลอร์พอสมาร์ทที่จะยอมรับการตั้งค่าที่goOnจะfalseเป็นถนนทางเดียวและใส่ที่ขาดหายไปgoto endสำหรับคุณ ด้วยเหตุนี้ประสิทธิภาพของโค้ดข้างต้นจะเหมือนกับของ a do/ while(0)โดยไม่กระทบต่อการอ่านที่เจ็บปวด

1. ลองแยกรหัสออกเป็นฟังก์ชันแยกต่างหาก (หรืออาจมากกว่าหนึ่ง) จากนั้นส่งคืนจากฟังก์ชันหากการตรวจสอบล้มเหลว

2. หากมันแน่นเกินไปกับรหัสรอบที่ทำเช่นนั้นและคุณไม่สามารถหาวิธีลดการคัปปลิ้งได้ให้ดูที่รหัสหลังจากบล็อกนี้ สันนิษฐานได้ว่ามันล้างทรัพยากรบางส่วนที่ใช้โดยฟังก์ชั่น พยายามที่จะจัดการทรัพยากรเหล่านี้โดยใช้วัตถุRAII ; จากนั้นแทนที่แต่ละ dodgy breakด้วยreturn(หรือthrowถ้าเหมาะสมกว่า) และให้ตัวทำลายวัตถุทำความสะอาดให้คุณ

3. หากโฟลว์ของโปรแกรมเป็น (จำเป็น) อย่างที่คุณต้องการจริงๆgotoแล้วให้ใช้มันแทนการปลอมตัวแปลก ๆ

4. หากคุณมีกฎการเข้ารหัสที่ห้ามมิให้สุ่มสี่สุ่มห้าgotoและคุณไม่สามารถทำให้การไหลเวียนของโปรแกรมง่ายขึ้นคุณอาจต้องปลอมแปลงมันด้วยdoแฮ็คของคุณ

TLDR : RAII , รหัสการทำธุรกรรม (ตั้งค่าผลลัพธ์หรือส่งคืนเนื้อหาเมื่อคำนวณแล้ว) และข้อยกเว้น

คำตอบยาว:

ในซีแนวทางปฏิบัติที่ดีที่สุดสำหรับโค้ดประเภทนี้คือการเพิ่ม EXIT / CLEANUP / เลเบลอื่น ๆในโค้ดที่มีการล้างทรัพยากรท้องถิ่นเกิดขึ้นและส่งคืนรหัสข้อผิดพลาด (ถ้ามี) นี่คือแนวปฏิบัติที่ดีที่สุดเนื่องจากแยกรหัสตามธรรมชาติในการกำหนดค่าเริ่มต้นการคำนวณกระทำและส่งคืน:

error_code_type c_to_refactor(result_type *r)
{
    error_code_type result = error_ok; //error_code_type/error_ok defd. elsewhere
    some_resource r1, r2; // , ...;
    if(error_ok != (result = computation1(&r1))) // Allocates local resources
        goto cleanup;
    if(error_ok != (result = computation2(&r2))) // Allocates local resources
        goto cleanup;
    // ...

    // Commit code: all operations succeeded
    *r = computed_value_n;
cleanup:
    free_resource1(r1);
    free_resource2(r2);
    return result;
}

ใน C ในโค้ดเบสส่วนใหญ่, if(error_ok != ...และgotoมักจะซ่อนอยู่ด้านหลังมาโครสะดวกซื้อบางตัว ( RET(computation_result),ENSURE_SUCCESS(computation_result, return_code)ฯลฯ )

C ++เสนอเครื่องมือพิเศษมากกว่า C :

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

• คุณโยนเมื่อใดก็ตามที่คุณไม่สามารถดำเนินการต่อเปลี่ยนทั้งหมด if(error_ok != ...เป็นสายตรง

รหัส C ++ ที่เทียบเท่ากัน:

result_type cpp_code()
{
    raii_resource1 r1 = computation1();
    raii_resource2 r2 = computation2();
    // ...
    return computed_value_n;
}

นี่เป็นแนวปฏิบัติที่ดีที่สุดเพราะ:

• มันชัดเจน (นั่นคือในขณะที่การจัดการข้อผิดพลาดไม่ชัดเจนกระแสหลักของอัลกอริทึมคือ)

• มันง่ายที่จะเขียนรหัสลูกค้า

• มันน้อยที่สุด

• มันง่าย

• มันไม่มีการสร้างรหัสซ้ำ

• มันไม่ใช้มาโคร

• มันไม่ได้ใช้do { ... } while(0)โครงสร้างที่แปลก

• มันสามารถนำกลับมาใช้ใหม่ได้โดยใช้ความพยายามน้อยที่สุด (นั่นคือถ้าฉันต้องการคัดลอกการเรียกไปcomputation2();ยังฟังก์ชันอื่นฉันไม่ต้องตรวจสอบให้แน่ใจว่าฉันเพิ่มdo { ... } while(0)รหัสใหม่ในโค้ดหรือ#defineแมโค wrapper และป้ายล้างข้อมูลหรือ สิ่งอื่นใด)

ฉันกำลังเพิ่มคำตอบเพื่อความสมบูรณ์ คำตอบอื่น ๆ จำนวนมากชี้ให้เห็นว่าบล็อกเงื่อนไขขนาดใหญ่สามารถแบ่งออกเป็นฟังก์ชันแยกต่างหาก แต่ตามที่ได้กล่าวไว้หลายครั้งก็คือวิธีการนี้จะแยกรหัสที่มีเงื่อนไขออกจากบริบทดั้งเดิม นี่คือเหตุผลหนึ่งที่เพิ่ม lambdas ให้กับภาษาใน C ++ 11 คนอื่นแนะนำให้ใช้ lambdas แต่ไม่มีการแจกตัวอย่างที่ชัดเจน ฉันได้ใส่ไว้ในคำตอบนี้ สิ่งที่ทำให้ฉันประทับใจคือมันให้ความรู้สึกคล้ายกับdo { } while(0)วิธีการหลายวิธี - และนั่นอาจหมายถึงว่ามันยังgotoแฝงตัวอยู่ ...

earlier operations
...
[&]()->void {

    if (!check()) return;
    ...
    ...
    if (!check()) return;
    ...
    ...
    if (!check()) return;
    ...
    ...
}();
later operations

ไม่แน่นอนคำตอบ แต่คำตอบ (เพื่อประโยชน์ของความสมบูรณ์)

แทน :

do {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

คุณสามารถเขียน:

switch (0) {
case 0:
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
}

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

การสร้างนั้นง่ายพอที่คุณสามารถหวังว่าคอมไพเลอร์จะปรับมันให้เหมาะสม

ตามที่แนะนำโดย @jamesdlin คุณสามารถซ่อนไว้ด้านหลังแมโครอย่างเช่น

#define BLOC switch(0) case 0:

และใช้งานได้เหมือนกัน

BLOC {
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
}

สิ่งนี้เป็นไปได้เนื่องจากไวยากรณ์ภาษา C คาดว่าจะมีคำสั่งหลังสวิตช์ไม่ใช่บล็อกที่อยู่ในวงเล็บและคุณสามารถใส่ป้ายชื่อเคสไว้ข้างหน้าคำสั่งนั้นได้ จนถึงตอนนี้ฉันไม่เห็นจุดอนุญาตให้ทำเช่นนั้น แต่ในกรณีนี้มันมีประโยชน์ที่จะซ่อนสวิตช์ไว้ด้านหลังมาโครที่ดี

gotoฉันจะแนะนำวิธีการคล้ายกับเสื่อคำตอบลบที่ไม่จำเป็น ใส่ตรรกะตามเงื่อนไขในฟังก์ชันเท่านั้น รหัสใด ๆ ที่ทำงานอยู่เสมอควรไปก่อนหรือหลังฟังก์ชันถูกเรียกใช้ในผู้เรียก:

void main()
{
    //do stuff always
    func();
    //do other stuff always
}

void func()
{
    if (!condition)
        return;
    ...
    if (!other condition)
        return;
    ...
    if (!another condition)
        return;
    ... 
    if (!yet another condition)
        return;
    ...
}

การไหลของรหัสตัวเองเป็นกลิ่นรหัสที่เกิดขึ้นมากในฟังก์ชั่น หากไม่มีวิธีการแก้ปัญหาโดยตรง (ฟังก์ชั่นนี้เป็นฟังก์ชั่นตรวจสอบทั่วไป) จากนั้นใช้RAIIเพื่อให้คุณสามารถกลับมาแทนที่จะกระโดดไปที่ส่วนท้ายของฟังก์ชันได้ดีกว่า

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

if (check()) {
  doStuff();
}  
if (stillOk()) {
  doMoreStuff();
}
if (amIStillReallyOk()) {
  doEvenMore();
}

// edit 
doThingsAtEndAndReportErrorStatus()

คล้ายกับคำตอบของ dasblinkenlight แต่หลีกเลี่ยงการมอบหมายภายในifที่อาจได้รับ "แก้ไข" โดยผู้ตรวจสอบรหัส:

bool goOn = check0();
if (goOn) {
    ...
    goOn = check1();
}
if (goOn) {
    ...
    goOn = check2();
}
if (goOn) {
    ...
}

...

ฉันใช้รูปแบบนี้เมื่อต้องตรวจสอบผลลัพธ์ของขั้นตอนก่อนขั้นตอนถัดไปซึ่งแตกต่างจากสถานการณ์ที่การตรวจสอบทั้งหมดสามารถทำได้ล่วงหน้าด้วยif( check1() && check2()...รูปแบบขนาดใหญ่

ใช้ข้อยกเว้น รหัสของคุณจะดูสะอาดกว่า (และมีการสร้างข้อยกเว้นสำหรับการจัดการข้อผิดพลาดในโฟลว์การเรียกใช้งานของโปรแกรม) สำหรับการล้างทรัพยากร (ตัวอธิบายไฟล์การเชื่อมต่อฐานข้อมูล ฯลฯ ) ให้อ่านบทความเหตุใด C ++ จึงไม่สร้างโครงสร้าง "ในที่สุด" .

#include <iostream>
#include <stdexcept>   // For exception, runtime_error, out_of_range

int main () {
    try {
        if (!condition)
            throw std::runtime_error("nope.");
        ...
        if (!other condition)
            throw std::runtime_error("nope again.");
        ...
        if (!another condition)
            throw std::runtime_error("told you.");
        ...
        if (!yet another condition)
            throw std::runtime_error("OK, just forget it...");
    }
    catch (std::runtime_error &e) {
        std::cout << e.what() << std::endl;
    }
    catch (...) {
        std::cout << "Caught an unknown exception\n";
    }
    return 0;
}

สำหรับฉันdo{...}while(0)เป็นเรื่องปกติ หากคุณไม่ต้องการที่จะเห็นdo{...}while(0)คุณสามารถกำหนดคำหลักทางเลือกสำหรับพวกเขา

ตัวอย่าง:

//--------SomeUtilities.hpp---------
#define BEGIN_TEST do{
#define END_TEST }while(0);

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) break;
   if(!condition2) break;
   if(!condition3) break;
   if(!condition4) break;
   if(!condition5) break;

   //processing code here

END_TEST

ฉันคิดว่าคอมไพเลอร์จะลบwhile(0)เงื่อนไขที่ไม่จำเป็นในdo{...}while(0)ในรุ่นไบนารีและแปลงตัวแบ่งเป็นการกระโดดแบบไม่มีเงื่อนไข คุณสามารถตรวจสอบเวอร์ชั่นภาษาแอสเซมบลีเพื่อให้แน่ใจ

การใช้gotoยังสร้างโค้ดที่สะอาดขึ้นและมันตรงไปตรงมากับลอจิกจากนั้นกระโดด คุณสามารถทำสิ่งต่อไปนี้:

{
   if(!condition1) goto end_blahblah;
   if(!condition2) goto end_blahblah;
   if(!condition3) goto end_blahblah;
   if(!condition4) goto end_blahblah;
   if(!condition5) goto end_blahblah;

   //processing code here

 }end_blah_blah:;  //use appropriate label here to describe...
                   //  ...the whole code inside the block.

หมายเหตุ: }ฉลากถูกวางไว้หลังจากปิด นี่คือการหลีกเลี่ยงปัญหาที่เป็นไปได้หนึ่งข้อในgotoการวางรหัสโดยบังเอิญเพราะคุณไม่เห็นป้ายกำกับ ตอนนี้มันเป็นเหมือนdo{...}while(0)ไม่มีรหัสเงื่อนไข

ในการทำให้โค้ดนี้สะอาดและเข้าใจง่ายขึ้นคุณสามารถทำได้:

//--------SomeUtilities.hpp---------
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) FAILED(NormalizeData);
   if(!condition2) FAILED(NormalizeData);
   if(!condition3) FAILED(NormalizeData);
   if(!condition4) FAILED(NormalizeData);
   if(!condition5) FAILED(NormalizeData);

END_TEST(NormalizeData)

ด้วยสิ่งนี้คุณสามารถทำบล็อกซ้อนกันและระบุตำแหน่งที่คุณต้องการออก / กระโดดออก

//--------SomeUtilities.hpp---------
#define BEGIN_TEST {
#define END_TEST(_test_label_) }_test_label_:;
#define FAILED(_test_label_) goto _test_label_

//--------SomeSourceFile.cpp--------
BEGIN_TEST
   if(!condition1) FAILED(NormalizeData);
   if(!condition2) FAILED(NormalizeData);

   BEGIN_TEST
      if(!conditionAA) FAILED(DecryptBlah);
      if(!conditionBB) FAILED(NormalizeData);   //Jump out to the outmost block
      if(!conditionCC) FAILED(DecryptBlah);

      // --We can now decrypt and do other stuffs.

   END_TEST(DecryptBlah)

   if(!condition3) FAILED(NormalizeData);
   if(!condition4) FAILED(NormalizeData);

   // --other code here

   BEGIN_TEST
      if(!conditionA) FAILED(TrimSpaces);
      if(!conditionB) FAILED(TrimSpaces);
      if(!conditionC) FAILED(NormalizeData);   //Jump out to the outmost block
      if(!conditionD) FAILED(TrimSpaces);

      // --We can now trim completely or do other stuffs.

   END_TEST(TrimSpaces)

   // --Other code here...

   if(!condition5) FAILED(NormalizeData);

   //Ok, we got here. We can now process what we need to process.

END_TEST(NormalizeData)

รหัสสปาเก็ตตี้ไม่ใช่ความผิดของgotoมันเป็นความผิดของโปรแกรมเมอร์ คุณยังสามารถสร้างรหัสสปาเก็ตตี้ได้โดยไม่ต้องใช้gotoคุณยังคงสามารถผลิตรหัสปาเก็ตตี้โดยไม่ต้องใช้

นี่เป็นปัญหาที่รู้จักกันดีและได้รับการแก้ไขเป็นอย่างดีจากมุมมองการเขียนโปรแกรมใช้งานซึ่งอาจเป็น monad

เพื่อตอบสนองต่อความคิดเห็นที่ฉันได้รับด้านล่างฉันได้แก้ไขคำแนะนำของฉันที่นี่: คุณสามารถดูรายละเอียดทั้งหมดเกี่ยวกับการนำC ++ monads ไปใช้ในสถานที่ต่าง ๆซึ่งจะช่วยให้คุณบรรลุสิ่งที่ Rotsor แนะนำ ต้องใช้เวลาสักครู่ในการคลาน monads ดังนั้นแทนที่จะฉันจะแนะนำที่นี่กลไก monad เหมือน "คนจน" อย่างรวดเร็วซึ่งคุณจำเป็นต้องรู้เกี่ยวกับอะไรมากกว่าการเพิ่ม :: ตัวเลือก

ตั้งค่าขั้นตอนการคำนวณของคุณดังนี้:

boost::optional<EnabledContext> enabled(boost::optional<Context> context);
boost::optional<EnergisedContext> energised(boost::optional<EnabledContext> context);

เห็นได้ชัดว่าแต่ละขั้นตอนการคำนวณสามารถทำอะไรบางอย่างเช่นผลตอบแทนboost::noneถ้ามันเป็นตัวเลือกที่ได้รับจะว่างเปล่า ตัวอย่างเช่น:

struct Context { std::string coordinates_filename; /* ... */ };

struct EnabledContext { int x; int y; int z; /* ... */ };

boost::optional<EnabledContext> enabled(boost::optional<Context> c) {
   if (!c) return boost::none; // this line becomes implicit if going the whole hog with monads
   if (!exists((*c).coordinates_filename)) return boost::none; // return none when any error is encountered.
   EnabledContext ec;
   std::ifstream file_in((*c).coordinates_filename.c_str());
   file_in >> ec.x >> ec.y >> ec.z;
   return boost::optional<EnabledContext>(ec); // All ok. Return non-empty value.
}

จากนั้นเชื่อมโยงพวกเขาเข้าด้วยกัน:

Context context("planet_surface.txt", ...); // Close over all needed bits and pieces

boost::optional<EnergisedContext> result(energised(enabled(context)));
if (result) { // A single level "if" statement
    // do work on *result
} else {
    // error
}

สิ่งที่ดีเกี่ยวกับเรื่องนี้คือคุณสามารถเขียนการทดสอบหน่วยที่กำหนดไว้อย่างชัดเจนสำหรับแต่ละขั้นตอนการคำนวณ นอกจากนี้การเรียกใช้จะอ่านเช่นภาษาอังกฤษธรรมดา (ตามปกติในกรณีที่มีสไตล์การทำงาน)

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

วิธีการเกี่ยวกับการย้ายคำสั่ง if เป็นฟังก์ชั่นพิเศษที่ให้ผลลัพธ์เป็นตัวเลขหรือ enum

int ConditionCode (void) {
   if (condition1)
      return 1;
   if (condition2)
      return 2;
   ...
   return 0;
}


void MyFunc (void) {
   switch (ConditionCode ()) {
      case 1:
         ...
         break;

      case 2:
         ...
         break;

      ...

      default:
         ...
         break;
   }
}

บางอย่างเช่นนี้อาจจะ

#define EVER ;;

for(EVER)
{
    if(!check()) break;
}

หรือใช้ข้อยกเว้น

try
{
    for(;;)
        if(!check()) throw 1;
}
catch()
{
}

การใช้ข้อยกเว้นคุณสามารถส่งผ่านข้อมูลได้

ฉันไม่ได้ใช้วิธีการเฉพาะbreakหรือreturnในกรณีเช่นนี้โดยเฉพาะ ระบุว่าโดยปกติเมื่อเราเผชิญสถานการณ์ดังกล่าวมักเป็นวิธีการที่ค่อนข้างยาว

หากเรามีจุดออกหลายจุดอาจทำให้เกิดปัญหาเมื่อเราต้องการรู้ว่าอะไรจะทำให้ตรรกะบางอย่างถูกดำเนินการ: โดยปกติแล้วเราจะขึ้นไปบนบล็อคที่ล้อมรอบส่วนของตรรกะนั้นและเกณฑ์ของบล็อกล้อมรอบนั้นบอกเราว่า สถานการณ์:

ตัวอย่างเช่น,

if (conditionA) {
    ....
    if (conditionB) {
        ....
        if (conditionC) {
            myLogic();
        }
    }
}

โดยการดูบล็อกที่ล้อมรอบมันเป็นเรื่องง่ายที่จะค้นหาว่าmyLogic()จะเกิดขึ้นเฉพาะเมื่อconditionA and conditionB and conditionCเป็นจริงเท่านั้น

มันจะมองเห็นได้น้อยลงเมื่อมีการคืนต้น:

if (conditionA) {
    ....
    if (!conditionB) {
        return;
    }
    if (!conditionD) {
        return;
    }
    if (conditionC) {
        myLogic();
    }
}

เราไม่สามารถนำทางจากอีกต่อไป myLogic()โดยดูที่การปิดล้อมบล็อกเพื่อกำหนดเงื่อนไข

มีวิธีแก้ไขปัญหาต่าง ๆ ที่ฉันใช้อยู่ นี่คือหนึ่งในนั้น:

if (conditionA) {
    isA = true;
    ....
}

if (isA && conditionB) {
    isB = true;
    ...
}

if (isB && conditionC) {
    isC = true;
    myLogic();
}

(แน่นอนว่ามันยินดีที่จะใช้ตัวแปรเดียวกันเพื่อแทนที่ทั้งหมด isA isB isC )

วิธีการดังกล่าวอย่างน้อยจะให้ผู้อ่านของรหัสที่จะดำเนินการเมื่อmyLogic() isB && conditionCผู้อ่านได้รับคำใบ้ว่าเขาต้องค้นหาเพิ่มเติมว่าอะไรจะทำให้ isB เป็นจริง

typedef bool (*Checker)();

Checker * checkers[]={
 &checker0,&checker1,.....，&checkerN,NULL
};

bool checker1(){
  if(condition){
    .....
    .....
    return true;
  }
  return false;
}

bool checker2(){
  if(condition){
    .....
    .....
    return true;
  }
  return false;
}

......

void doCheck(){
  Checker ** checker = checkers;
  while( *checker && (*checker)())
    checker++;
}

แล้วเรื่องนั้นล่ะ

รูปแบบอื่นที่มีประโยชน์หากคุณต้องการขั้นตอนการล้างข้อมูลที่แตกต่างกันขึ้นอยู่กับความล้มเหลว:

    private ResultCode DoEverything()
    {
        ResultCode processResult = ResultCode.FAILURE;
        if (DoStep1() != ResultCode.SUCCESSFUL)
        {
            Step1FailureCleanup();
        }
        else if (DoStep2() != ResultCode.SUCCESSFUL)
        {
            Step2FailureCleanup();
            processResult = ResultCode.SPECIFIC_FAILURE;
        }
        else if (DoStep3() != ResultCode.SUCCESSFUL)
        {
            Step3FailureCleanup();
        }
        ...
        else
        {
            processResult = ResultCode.SUCCESSFUL;
        }
        return processResult;
    }

ฉันไม่ใช่โปรแกรมเมอร์C ++ดังนั้นฉันจะไม่เขียนโค้ดใด ๆ ที่นี่ แต่จนถึงขณะนี้ยังไม่มีใครได้พูดถึงวิธีแก้ปัญหาเชิงวัตถุ ดังนั้นที่นี่ฉันเดาว่า

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

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

อย่างไรก็ตามข้อเสียคือมีค่าใช้จ่ายเพิ่มขึ้นเล็กน้อยเนื่องจากการใช้วัตถุมากขึ้นและการวนซ้ำในรายการ

นี่คือวิธีที่ฉันทำ

void func() {
  if (!check()) return;
  ...
  ...

  if (!check()) return;
  ...
  ...

  if (!check()) return;
  ...
  ...
}

ขั้นแรกเป็นตัวอย่างสั้น ๆ เพื่อแสดงว่าทำไมจึงgotoไม่ใช่วิธีแก้ปัญหาที่ดีสำหรับ C ++:

struct Bar {
    Bar();
};

extern bool check();

void foo()
{
    if (!check())
       goto out;

    Bar x;

    out:
}

ลองรวบรวมสิ่งนี้เป็นไฟล์วัตถุและดูว่าเกิดอะไรขึ้น จากนั้นลองใช้doเครื่องหมายbreak+ +while(0) +

นั่นคือการกัน ประเด็นหลักดังต่อไปนี้

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

ทางเลือกหนึ่งในการรับความหมายเหล่านี้คือRAII ; ดูคำตอบของ @ utnapistim C ++ รับประกันว่า destructors อัตโนมัติจะทำงานในลำดับตรงกันข้ามกับ constructors ซึ่งโดยธรรมชาติจะเป็น "คลี่คลาย"

แต่นั่นต้องใช้คลาส RAII มากมาย บางครั้งตัวเลือกที่ง่ายกว่าก็คือใช้สแต็ก:

bool calc1()
{
    if (!check())
        return false;

    // ... Do stuff1 here ...

    if (!calc2()) {
        // ... Undo stuff1 here ...
        return false;
    }

    return true;
}

bool calc2()
{
    if (!check())
        return false;

    // ... Do stuff2 here ...

    if (!calc3()) {
        // ... Undo stuff2 here ...
        return false;
    }

    return true;
}

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

มันอาจต้องการcalcฟังก์ชั่นในการรับอาร์กิวเมนต์มากมาย แต่โดยปกติจะไม่เป็นปัญหาหากคลาส / โครงสร้างของคุณมีการเชื่อมโยงที่ดี (นั่นคือสิ่งที่อยู่ร่วมกันอาศัยอยู่ในวัตถุเดียวดังนั้นฟังก์ชั่นเหล่านี้สามารถใช้เป็นตัวชี้หรือการอ้างอิงถึงวัตถุจำนวนน้อยและยังทำงานที่มีประโยชน์มากมาย)

หากคุณมีรหัสบล็อกยาวของ if..else if..else งบคุณอาจลองและเขียนบล็อกทั้งหมดด้วยความช่วยเหลือของหรือFunctors function pointersมันอาจไม่ใช่ทางออกที่ถูกต้องเสมอไป แต่บ่อยครั้งก็คือ

http://www.cprogramming.com/tutorial/functors-function-objects-in-c++.html

ฉันประหลาดใจกับจำนวนคำตอบที่ต่างกันที่นำเสนอที่นี่ แต่ในที่สุดในรหัสที่ฉันต้องเปลี่ยน (เช่นลบdo-while(0)แฮ็คนี้หรืออะไรก็ได้) ฉันทำสิ่งที่แตกต่างจากคำตอบที่กล่าวถึงที่นี่และฉันสับสนว่าทำไมไม่มีใครคิดเรื่องนี้ นี่คือสิ่งที่ฉันทำ:

รหัสเริ่มต้น:

do {

    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
    if(!check()) break;
    ...
    ...
} while(0);

finishingUpStuff.

ขณะนี้:

finish(params)
{
  ...
  ...
}

if(!check()){
    finish(params);    
    return;
}
...
...
if(!check()){
    finish(params);    
    return;
}
...
...
if(!check()){
    finish(params);    
    return;
}
...
...

ดังนั้นสิ่งที่ทำที่นี่คือการตกแต่งสิ่งที่แยกได้ในฟังก์ชั่นและสิ่งที่กลายเป็นเรียบง่ายและสะอาด!

ฉันคิดว่าวิธีนี้คุ้มค่าที่จะพูดถึงดังนั้นให้มาที่นี่

รวมเข้าไว้ในifคำสั่งเดียว:

if(
    condition
    && other_condition
    && another_condition
    && yet_another_condition
    && ...
) {
        if (final_cond){
            //Do stuff
        } else {
            //Do other stuff
        }
}

นี่เป็นรูปแบบที่ใช้ในภาษาต่างๆเช่น Java ซึ่งมีการลบคำหลัก goto

หากใช้ตัวจัดการข้อผิดพลาดเดียวกันสำหรับข้อผิดพลาดทั้งหมดและแต่ละขั้นตอนจะส่งกลับค่าบูลที่ระบุว่าสำเร็จ:

if(
    DoSomething() &&
    DoSomethingElse() &&
    DoAThirdThing() )
{
    // do good condition action
}
else
{
    // handle error
}

(คล้ายกับคำตอบของ tyzoid แต่เงื่อนไขเป็นการกระทำและ && ป้องกันการกระทำเพิ่มเติมที่เกิดขึ้นหลังจากความล้มเหลวครั้งแรก)

ทำไมไม่มีการตั้งค่าสถานะวิธีตอบถูกใช้มาตั้งแต่สมัยโบราณ

//you can use something like this (pseudocode)
long var = 0;
if(condition)  flag a bit in var
if(condition)  flag another bit in var
if(condition)  flag another bit in var
............
if(var == certain number) {
Do the required task
}