คำว่า "while (จริง)" วนซ้ำกับ "break" ด้านในคืออะไร [ปิด]

สมมติว่าฉันมีวงใน C ++ หรือ C # ที่เป็นเช่นนี้:

while( true ) {
    doSomething();
    if( condition() ) {
        break;
    }
    doSomethingElse();
}

สิ่งนี้เรียกว่า "infinite loop" แต่มันเป็นไปไม่ได้ในทางเทคนิคอนันต์ - breakมันจะหยุดทันทีที่ควบคุมการไหลผ่าน

คำสำหรับวงดังกล่าวคืออะไร - ที่มีคำสั่งการควบคุมแบบวนซ้ำ "ตลอดไป" และ "ตัวแบ่ง" ภายใน

การศึกษา CS ศาสตราจารย์นี้สอนเราว่ามีลูปก่อนตรวจสอบ ( while(cond) {}) หลังการตรวจสอบลูป ( do {} while(cond);) และลูปกลางตรวจสอบ (ฉันอาจแปลสิ่งนี้เป็นภาษาอังกฤษได้ไม่ดี แต่คุณได้ความคิด)

C และ C ++ ไม่มีหลัง (ISTR Ada มี BICBW) ดังนั้นโครงสร้างของคุณจะใช้สำหรับสิ่งนั้นใน C และ C ++

หลักสูตรแรกมากในการบริการลูกค้าที่ Stanford ( Programming วิธีโดย Mehran Sahami ) หมายถึงนี้เป็นห่วงและครึ่งหนึ่ง และมันก็ไม่จำเป็นต้องฝึกเขียนโปรแกรมเสีย ลองพิจารณาตัวอย่างนี้ในการรวบรวมการป้อนข้อมูลของผู้ใช้ (นำมาจากศิลปะและวิทยาศาสตร์ของ Java โดย Eric Robertsโดยที่ Roberts เรียกว่าa-loop-and-a-half ):

prompt user and read in the first value
while (value != sentinel) {
    process the data value
    prompt user and read in a new value
}

จากนั้นสิ่งเดียวกันก็แก้ไขโดยใช้ลูปและแนวคิดครึ่งหนึ่งเพื่อหลีกเลี่ยงโค้ดที่ซ้ำกัน:

while (true) {
    prompt user and read in a value
    if (value == sentinel) break;
    process the data value
}

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

ไม่มีชื่อที่ชัดเจน ฉันคิดว่าวงที่ไม่มีที่สิ้นสุดเป็นคำที่เหมาะสม ไม่มีลูปไม่มีที่สิ้นสุดอย่างแท้จริง แต่นี่มีศักยภาพที่จะไม่มีที่สิ้นสุดอย่างมีประสิทธิภาพเนื่องจากเป็นไปได้ว่าสาขาที่มีการแตกจะไม่เกิดขึ้น

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

มันวนซ้ำในขณะที่มีเงื่อนไขอยู่ผิดที่

ฉันจะลงคะแนนให้กับ"การวนรอบแบบไม่มีเงื่อนไข"ซึ่งคล้ายกับ "การกระโดดแบบไม่มีเงื่อนไข" มันแสดงให้เห็นว่าสิ่งที่เกิดขึ้น (รหัสลูปไม่มีเงื่อนไข) โดยไม่โกหก (ต่างจาก "infinite loop")

คำสำหรับวงดังกล่าวคืออะไร - ที่มีคำสั่งการควบคุมแบบวนซ้ำ "ตลอดไป" และ "ตัวแบ่ง" ภายใน

มันเป็นวงที่ไม่มีที่สิ้นสุดพร้อมเงื่อนไขการพัก

ฉันเห็นด้วยกับกระสุนในกรณีที่คุณต้องการตั้งชื่อพิเศษคุณสามารถเรียกมันว่าInfinite Partial Loop

เมื่อวันที่ Rosetta รหัสรูปแบบนี้โดยเฉพาะอย่างยิ่งมีการอธิบายไว้ในฐานะที่เป็น“N บวกครึ่งหนึ่ง” ห่วง แม้ว่ามันจะไม่ใช่คำศัพท์ที่ฉันชอบ แต่ก็ไม่ได้แย่และเป็นรูปแบบที่ชัดเจนว่ามีประโยชน์สำหรับลูปบางประเภท (ทางเลือกคือการทำซ้ำรหัสก่อนเงื่อนไขซึ่งอาจเป็นเรื่องยุ่งยากในโปรแกรมจริงหรือเพื่อเพิ่มความลึกในการซ้อนของโค้ดหลังเงื่อนไขขณะที่เพิ่มตัวแปรเงื่อนไขลูปไม่ปรับปรุงความสามารถในการบำรุงรักษาหรือความเข้าใจโค้ด . เหตุผลเดียวที่ปฏิเสธการสร้างเช่นนี้คือถ้ามีคนยืนยันที่จะเขียนลูปเป็นbreakอิสระ)

ไม่มีระยะมาตรฐานคือ แต่ผมจะบอกว่ามันเป็นห่วงบางส่วน

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

ในกรณีนี้คุณต้องการทำลายลูปหลังจากดำเนินการอย่างน้อยdoSomething()หนึ่งครั้งล่าสุด

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

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

ในกรณีเฉพาะของคุณห่วงของคุณเทียบเท่า

for(; doSomething(), !condition(); doSomethingElse()){}

ดังนั้นฉันจะใช้เฉพาะbreakรุ่นหากมีส่วนร่วมdoSomethingหรือdoSomethingElseมีหลายงบและฉันไม่ควรเก็บไว้ในฟังก์ชั่นที่แยกต่างหากอย่างที่คุณทำ

ที่กล่าวว่าหากการวนซ้ำของคุณซับซ้อนมากขึ้นการทำซ้ำ (เริ่มตรวจสอบเพิ่ม) คุณควรพิจารณาการปรับโครงสร้างให้เป็นสิ่งที่เรียบง่ายกว่า

ฉันเดาว่าถ้าเราจะลองทำศัพท์สำหรับเรื่องนี้อาจจะ:

หนีไม่พ้นห่วง

ฉันเรียกมันว่าเป็น "ในขณะที่วงจริง"

ยังเห็นว่าในขณะที่ (จริง) การฝึกเขียนโปรแกรมไม่ดี

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

while (loop
    .getAExecutionModelFactory()
    .getActiveXexecutor()
    .getYCancelModelHandler()
    .getCurrentHandler()
    .isCancelled()) {
        // ... do something with the current Handler ....
        loop = ..... // prepare for next loop
}

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