ทำ {…} while (เท็จ)

ฉันกำลังดูรหัสบางอย่างโดยบุคคลและสังเกตเห็นว่าเขาดูเหมือนจะมีรูปแบบในฟังก์ชั่นของเขา:

<return-type> function(<params>)
{
 <initialization>

 do
 {
   <main code for function>
 }
 while(false);

 <tidy-up & return>
}

มันไม่เลวแปลกกว่านั้น (รหัสจริงค่อนข้างเรียบร้อยและไม่น่าแปลกใจ) ไม่ใช่สิ่งที่ฉันเคยเห็นมาก่อนและฉันสงสัยว่ามีใครสามารถคิดตรรกะเบื้องหลังมันได้หรือไม่ - อาจมีพื้นหลังเป็นภาษาอื่น?

คุณสามารถbreakออกจากdo{...}while(false).

หลายคนชี้ให้เห็นว่ามักใช้กับตัวแบ่งเป็นวิธีการเขียน "goto" ที่น่าอึดอัด นั่นอาจเป็นความจริงถ้าเขียนลงในฟังก์ชันโดยตรง

ในมาโคร OTOH do { something; } while (false)เป็นวิธีที่สะดวกในการบังคับใช้อัฒภาคหลังจากการเรียกใช้มาโครโดยไม่อนุญาตให้ใช้โทเค็นอื่น ๆ

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

การหยุดพักเป็น goto น่าจะเป็นคำตอบ แต่ฉันจะหยิบยกแนวคิดอื่น ๆ

บางทีเขาอาจต้องการมีตัวแปรที่กำหนดในพื้นที่และใช้โครงสร้างนี้เพื่อรับขอบเขตใหม่

โปรดจำไว้ว่าในขณะที่ C ++ ล่าสุดอนุญาตให้ใช้ได้{...}ทุกที่ แต่ก็ไม่ได้เป็นเช่นนั้นเสมอไป

ฉันเห็นว่ามันใช้เป็นรูปแบบที่มีประโยชน์เมื่อมีจุดออกที่เป็นไปได้หลายจุดสำหรับฟังก์ชัน แต่จำเป็นต้องใช้รหัสการล้างข้อมูลเดียวกันเสมอไม่ว่าฟังก์ชันจะออกอย่างไร

มันสามารถทำให้ต้นไม้ if / else-if ที่น่าเบื่อหน่ายง่ายต่อการอ่านมากโดยเพียงแค่ต้องทำลายทุกครั้งที่ถึงจุดออกพร้อมกับตรรกะที่เหลือในบรรทัดหลังจากนั้น

รูปแบบนี้ยังมีประโยชน์ในภาษาที่ไม่มีคำสั่ง goto บางทีนั่นอาจเป็นสิ่งที่โปรแกรมเมอร์ดั้งเดิมได้เรียนรู้รูปแบบ

ฉันเคยเห็นรหัสแบบนั้นเพื่อให้คุณสามารถใช้breakเป็นgotoประเภทต่างๆ

นี่เป็นเพียงการบิดเบือนwhileเพื่อให้ได้สัญศาสตร์goto tidy-upโดยไม่ต้องใช้คำว่า goto

มันเป็นรูปแบบที่ไม่ดีเพราะเมื่อคุณใช้อื่น ๆลูปภายในภายนอกกลายเป็นคลุมเครือให้ผู้อ่าน "นี่มันควรจะไปที่ทางออกแล้วหรือนี่มันตั้งใจจะหลุดจากวงในเท่านั้น"whilebreaks

ฉันคิดว่ามันสะดวกกว่าที่จะเขียนแทนbreak goto endคุณไม่จำเป็นต้องคิดชื่อสำหรับป้ายกำกับซึ่งทำให้ความตั้งใจชัดเจนขึ้น: คุณไม่ต้องการข้ามไปยังป้ายกำกับที่มีชื่อเฉพาะ คุณต้องการออกไปจากที่นี่

ยังมีโอกาสที่คุณจะต้องจัดฟันด้วย นี่คือdo{...}while(false);เวอร์ชัน:

do {
   // code
   if (condition) break; // or continue
   // more code
} while(false);

และนี่คือวิธีที่คุณจะต้องแสดงออกหากคุณต้องการใช้goto:

{
   // code
   if (condition) goto end;
   // more code
}
end:

ฉันคิดว่าความหมายของเวอร์ชันแรกนั้นเข้าใจง่ายกว่ามาก นอกจากนี้ยังเขียนได้ง่ายขึ้นขยายง่ายขึ้นแปลเป็นภาษาที่ไม่รองรับได้ง่ายขึ้นgotoฯลฯ

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

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

ถือเป็นเรื่องธรรมดามาก ในC ฉันพยายามคิดว่าถ้าคุณต้องการโกหกตัวเองแบบว่า "ฉันไม่ได้ใช้กgoto" คิดเกี่ยวกับมันจะไม่มีอะไรผิดปกติกับการgotoใช้ในทำนองเดียวกัน ในความเป็นจริงมันจะลดระดับการเยื้องด้วย

ที่กล่าวว่าฉันสังเกตเห็นบ่อยครั้งที่do..whileลูปนี้มักจะโตขึ้น แล้วพวกเขาก็จะได้ifs and elses เข้าไปข้างในทำให้โค้ดนั้นอ่านไม่ได้จริง ๆ นับประสาอะไรกับการทดสอบ

ผู้ที่do..whileมีความตั้งใจที่ปกติจะทำสะอาดขึ้น โดยทั้งหมดเป็นไปได้ฉันต้องการใช้RAIIและกลับมาก่อนเวลาจากฟังก์ชันสั้น ๆ ในทางกลับกันCไม่ได้อำนวยความสะดวกให้คุณมากเท่ากับC ++ทำให้เป็นdo..whileหนึ่งในวิธีที่ดีที่สุดในการล้างข้อมูล

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

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

คำอธิบายหลายประการ อันแรกเป็นแบบทั่วไปอันที่สองเฉพาะสำหรับมาโครตัวประมวลผลล่วงหน้า C ที่มีพารามิเตอร์:

การควบคุมการไหล

ฉันเคยเห็นสิ่งนี้ใช้ในรหัส C ธรรมดา โดยพื้นฐานแล้วมันเป็น goto เวอร์ชันที่ปลอดภัยกว่าเนื่องจากคุณสามารถแยกออกได้และหน่วยความจำทั้งหมดจะได้รับการทำความสะอาดอย่างเหมาะสม

ทำไมบางสิ่งบางอย่างถึงgotoดี? ถ้าคุณมีโค้ดที่เกือบทุกบรรทัดสามารถส่งคืนข้อผิดพลาดได้ แต่คุณต้องตอบสนองต่อทั้งหมดในลักษณะเดียวกัน (เช่นโดยการส่งข้อผิดพลาดไปยังผู้โทรของคุณหลังจากล้างข้อมูล) โดยปกติแล้วจะสามารถอ่านได้มากกว่าเพื่อหลีกเลี่ยงif( error ) { /* cleanup and error string generation and return here */ }as หลีกเลี่ยงการทำซ้ำรหัสการล้างข้อมูล

อย่างไรก็ตามใน C ++ คุณมีข้อยกเว้น + RAII สำหรับจุดประสงค์นี้ดังนั้นฉันคิดว่ารูปแบบการเข้ารหัสไม่ดี

การตรวจสอบอัฒภาค

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

#define PRINT_IF_DEBUGMODE_ON(msg) if( gDebugModeOn ) printf("foo");

ที่เรียกโดยบังเอิญว่าเป็น

if( foo )
    PRINT_IF_DEBUGMODE_ON("Hullo\n")
else
    doSomethingElse();

"else" จะถูกพิจารณาว่ามีความเกี่ยวข้องgDebugModeOnดังนั้นเมื่อfooใดfalseที่การย้อนกลับที่แน่นอนของสิ่งที่ตั้งใจไว้จะเกิดขึ้น

กำหนดขอบเขตสำหรับตัวแปรชั่วคราว

เนื่องจาก do / while มีวงเล็บปีกกาตัวแปรชั่วคราวจึงมีขอบเขตที่กำหนดไว้อย่างชัดเจนจึงไม่สามารถหลีกเลี่ยงได้

หลีกเลี่ยงคำเตือน "อัฒภาคที่อาจไม่ต้องการ"

มาโครบางตัวเปิดใช้งานเฉพาะในรุ่นแก้จุดบกพร่องเท่านั้น คุณกำหนดพวกเขาเช่น:

#if DEBUG
#define DBG_PRINT_NUM(n) printf("%d\n",n);
#else
#define DBG_PRINT_NUM(n) 
#endif

ตอนนี้ถ้าคุณใช้สิ่งนี้ในรีลีสบิลด์ภายในเงื่อนไขจะคอมไพล์

if( foo )
    ;

คอมไพเลอร์หลายคนเห็นว่าสิ่งนี้เหมือนกับไฟล์

if( foo );

ซึ่งมักเขียนโดยบังเอิญ. คุณจึงได้รับคำเตือน do {} while (false) ซ่อนสิ่งนี้จากคอมไพลเลอร์และได้รับการยอมรับว่าเป็นสิ่งที่บ่งบอกว่าคุณไม่ต้องการทำอะไรเลยที่นี่

การหลีกเลี่ยงการจับเส้นตามเงื่อนไข

มาโครจากตัวอย่างก่อนหน้านี้:

if( foo )
    DBG_PRINT_NUM(42)
doSomething();

ตอนนี้ในการสร้างการดีบักเนื่องจากเรารวมอัฒภาคเป็นนิสัยการคอมไพล์นี้ใช้ได้ดี อย่างไรก็ตามในการสร้างรุ่นนี้จะกลายเป็น:

if( foo )

doSomething();

หรือจัดรูปแบบให้ชัดเจนยิ่งขึ้น

if( foo )
    doSomething();

ซึ่งไม่ใช่สิ่งที่ตั้งใจไว้เลย การเพิ่ม do {... } ในขณะที่ (false) รอบ ๆ มาโครจะเปลี่ยนอัฒภาคที่หายไปให้เป็นข้อผิดพลาดในการคอมไพล์

นั่นหมายความว่าอย่างไรสำหรับ OP?

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

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

do {
    if (!condition1) break;
    some_code;
    if (!condition2) break;
    some_further_code;
    // …
} while(false);

ผมว่าทำเพื่อใช้breakหรือcontinueงบ ตรรกะรหัส "goto" บางประเภท

มันง่ายมาก: เห็นได้ชัดว่าคุณสามารถกระโดดออกจากลูปปลอมได้ตลอดเวลาโดยใช้breakคำสั่ง นอกจากนี้doบล็อกยังเป็นขอบเขตแยกต่างหาก (ซึ่งสามารถทำได้ด้วย{ ... }เท่านั้น)

ในสถานการณ์เช่นนี้ควรใช้ RAII (วัตถุจะทำลายโดยอัตโนมัติอย่างถูกต้องเมื่อฟังก์ชันสิ้นสุดลง) โครงสร้างอื่นที่คล้ายกันคือการใช้goto- ใช่ฉันรู้ว่ามันชั่วร้ายแต่สามารถใช้เพื่อมีรหัสล้างข้อมูลทั่วไปได้ดังนี้:

<return-type> function(<params>)
{
 <initialization>

 <main code for function using "goto error;" if something goes wrong>

 <tidy-up in success case & return>

 error:

 <commmon tidy-up actions for error case & return error code or throw exception>
}

(นอกเหนือจาก: โครงสร้าง do-while-false ถูกใช้ใน Lua เพื่อหาcontinueคำสั่งที่ขาดหายไป)

ผู้ตอบหลายคนให้เหตุผลdo{(...)break;}while(false)ว่า ฉันอยากจะเติมเต็มภาพด้วยอีกตัวอย่างในชีวิตจริง

ในรหัสต่อไปนี้ฉันต้องตั้งค่าตัวนับoperationตามที่อยู่ที่ชี้ไปโดยdataตัวชี้ เนื่องจากสวิตช์เคสสามารถใช้ได้เฉพาะกับประเภทสเกลาร์ก่อนอื่นฉันจึงทำแบบนี้อย่างไม่มีประสิทธิภาพ

if (data == &array[o1])
    operation = O1;
else if (data == &array[o2])
    operation = O2;
else if (data == &array[on])
    operation = ON;

Log("operation:",operation);

แต่เนื่องจาก Log () และโค้ดส่วนที่เหลือซ้ำกันสำหรับค่าการดำเนินการใด ๆ ที่เลือกฉันจึงหลงทางว่าจะข้ามการเปรียบเทียบส่วนที่เหลืออย่างไรเมื่อพบที่อยู่แล้ว และนี่คือจุดที่do{(...)break;}while(false)มีประโยชน์

do {
    if (data == &array[o1]) {
        operation = O1;
        break;
    }
    if (data == &array[o2]) {
        operation = O2;
        break;
    }
    if (data == &array[on]) {
        operation = ON;
        break;
    }
} while (false);

Log("operation:",operation);

บางคนอาจสงสัยว่าทำไมเขาถึงทำแบบเดียวกันกับbreakในifแถลงการณ์ไม่ได้เช่น:

if (data == &array[o1])
{
    operation = O1;
    break;
}
else if (...)

breakปฏิสัมพันธ์ แต่เพียงผู้เดียวกับการปิดล้อมอยู่ใกล้ห่วงหรือสวิทช์ไม่ว่าจะเป็นfor, whileหรือdo .. whileประเภทจึงน่าเสียดายที่จะไม่ทำงาน

ผู้เขียนอายุเท่าไร?

ฉันถามเพราะครั้งหนึ่งฉันเจอรหัส Fortran แบบเรียลไทม์ที่ทำแบบนั้นย้อนกลับไปในช่วงปลายยุค 80 ปรากฎว่าเป็นวิธีที่ดีมากในการจำลองเธรดบนระบบปฏิบัติการที่ไม่มี คุณเพียงแค่ใส่โปรแกรมทั้งหมด (ตัวกำหนดตารางเวลาของคุณ) ในลูปแล้วเรียก "เธรด" รูทีน "ทีละรายการรูทีนเธรดเองก็คือลูปที่วนซ้ำจนกว่าจะมีเงื่อนไขใดเงื่อนไขหนึ่งเกิดขึ้น (โดยมากจะเป็นจำนวนหนึ่ง เวลาผ่านไปแล้ว) มันคือ "การทำงานหลายอย่างแบบร่วมมือกัน" ซึ่งขึ้นอยู่กับแต่ละเธรดที่จะเลิกใช้ CPU ทุก ๆ ครั้งเพื่อไม่ให้คนอื่นอดอาหารคุณสามารถซ้อนการเรียกโปรแกรมย่อยแบบวนซ้ำเพื่อจำลองลำดับความสำคัญของเธรด วงดนตรี

นอกเหนือจาก 'goto Example' ที่กล่าวไปแล้วสำนวน do ... ในขณะที่ (0) บางครั้งใช้ในนิยามมาโครเพื่อจัดเตรียมวงเล็บในนิยามและยังคงให้คอมไพเลอร์ทำงานโดยเพิ่มเซมิโคลอนต่อท้าย การโทรแบบมาโคร

http://groups.google.com/group/comp.soft-sys.ace/browse_thread/thread/52f670f1292f30a4?tvc=2&q=while+(0)

ฉันเห็นด้วยกับผู้โพสต์ส่วนใหญ่เกี่ยวกับการใช้โกโตะที่ปลอมตัวบาง ๆ มาโครยังได้รับการกล่าวถึงว่าเป็นแรงจูงใจที่เป็นไปได้สำหรับการเขียนโค้ดในรูปแบบ

ฉันยังเห็นโครงสร้างนี้ที่ใช้ในสภาพแวดล้อม C / C ++ แบบผสมเป็นข้อยกเว้นของคนยากจน "do {} while (false)" กับ "break" สามารถใช้เพื่อข้ามไปยังจุดสิ้นสุดของบล็อกโค้ดได้หากพบข้อยกเว้นในลูป

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

ฉันทำงานกับ Adobe InDesign SDK และตัวอย่าง InDesign SDK มีเกือบทุกฟังก์ชันที่เขียนแบบนี้ เนื่องมาจากว่าฟังก์ชันมักจะยาวมาก ที่คุณต้องทำ QueryInterface (... ) เพื่อรับอะไรก็ได้จากโมเดลวัตถุแอปพลิเคชัน ดังนั้นโดยปกติแล้วทุก QueryInterface จะตามมาด้วยifไม่เป็นไปด้วยดีทำลาย

หลายคนได้กล่าวถึงความคล้ายคลึงกันระหว่างโครงสร้างนี้และ a gotoแล้วและแสดงความพึงพอใจต่อ goto บางทีภูมิหลังของบุคคลนี้อาจรวมถึงสภาพแวดล้อมที่ goto ถูกห้ามอย่างเคร่งครัดตามแนวทางการเขียนโค้ด?

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

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

ดูTrivial Do While loopและวงเล็บปีกกาเป็นสิ่งที่ดีจาก C2

เพื่อชี้แจงคำศัพท์ของฉัน (ซึ่งฉันเชื่อว่าเป็นไปตามการใช้งานมาตรฐาน):

การจัดฟันแบบเปล่า :

init();
...
{
c = NULL;
mkwidget(&c);
finishwidget(&c);
}
shutdown();

เครื่องมือจัดฟันเปล่า (NOP):

{}

เช่น

while (1)
   {}  /* Do nothing, endless loop */

บล็อก :

if (finished)
{
     closewindows(&windows);
     freememory(&cache);
}

ซึ่งจะกลายเป็น

if (finished)
     closewindows(&windows);
freememory(&cache);

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

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

เป็นวิธีที่ออกแบบมาเพื่อเลียนแบบGOTOเนื่องจากทั้งสองเหมือนกันจริง:

// NOTE: This is discouraged!
do {
    if (someCondition) break;
    // some code be here
} while (false);
// more code be here

และ:

// NOTE: This is discouraged, too!
if (someCondition) goto marker;
// some code be here
marker:
// more code be here

ในทางกลับกันทั้งสองอย่างนี้ควรจะทำด้วยifs:

if (!someCondition) {
    // some code be here
}
// more code be here

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

หากคุณพยายามทับศัพท์อัลกอริทึมที่มีGOTOs อยู่ในนั้นอย่างสิ้นหวังคุณอาจทำได้ด้วยสำนวนนี้ แน่นอนว่ามันไม่ได้มาตรฐานและเป็นตัวบ่งชี้ที่ดีว่าคุณไม่ได้ยึดมั่นอย่างใกล้ชิดกับสำนวนภาษาที่คาดหวังไว้

ฉันไม่ทราบว่ามีภาษาคล้าย C ใด ๆ ที่ do / while เป็นวิธีแก้ปัญหาสำหรับทุกสิ่งจริงๆ

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

ผู้เขียนโค้ดบางรายต้องการให้มีเพียงทางออกเดียว / กลับจากฟังก์ชันของตน การใช้หุ่นจำลองทำ {.... } while (false); ช่วยให้คุณ "แยกออก" จากการวนซ้ำแบบจำลองเมื่อคุณทำเสร็จแล้วและยังคงได้รับผลตอบแทนเพียงครั้งเดียว

ฉันเป็นคนเขียนโค้ดจาวาดังนั้นตัวอย่างของฉันจะเป็นอย่างไร

import java.util.Arrays;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class p45
{
    static List<String> cakeNames = Arrays.asList("schwarzwald torte", "princess", "icecream");
    static Set<Integer> forbidden = Stream.of(0, 2).collect(Collectors.toSet());

    public static  void main(String[] argv)
    {
        for (int i = 0; i < 4; i++)
        {
            System.out.println(String.format("cake(%d)=\"%s\"", i, describeCake(i)));
        }
    }


    static String describeCake(int typeOfCake)
    {
        String result = "unknown";
        do {
            // ensure type of cake is valid
            if (typeOfCake < 0 || typeOfCake >= cakeNames.size()) break;

            if (forbidden.contains(typeOfCake)) {
                result = "not for you!!";
                break;
            }

            result = cakeNames.get(typeOfCake);
        } while (false);
        return result;
    }
}

ในกรณีเช่นนี้ฉันใช้

switch(true) {
   case condution1:
      ...
      break;
   case condution2:
      ...
      break;
}

นี่เป็นเรื่องน่าขบขัน อาจมีรอยแตกในวงดังที่คนอื่นพูด ฉันจะทำแบบนี้:

while(true)
{
   <main code for function>
   break; // at the end.
}