เหตุใดคำสั่งสวิตช์จึงถูกออกแบบมาเพื่อให้หยุดพัก

รับงบสวิตช์ง่าย

switch (int)
{
    case 1 :
    {
        printf("1\n");
        break;
    }

    case 2 : 
    {
        printf("2\n");
    }

    case 3 : 
    {
        printf("3\n");
    }
}

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

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

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

Peter Van der Linden ทำคดีนี้ในหนังสือของเขา "Expert C Programming":

เราวิเคราะห์แหล่งคอมไพเลอร์ของ Sun C เพื่อดูว่ามีการใช้ค่าเริ่มต้นในการล่มสลายบ่อยแค่ไหน ส่วนหน้าคอมไพเลอร์ Sun ANSI C มีคำสั่งสวิตช์ 244 รายการแต่ละรายการมีค่าเฉลี่ยเจ็ดกรณี ล้มลงเกิดขึ้นเพียง 3% ของทุกกรณี

กล่าวอีกนัยหนึ่งพฤติกรรมสวิตช์ปกติคือ ผิด 97% ของเวลา ไม่ใช่แค่ในคอมไพเลอร์ - ในทางกลับกันที่การล่มสลายถูกนำมาใช้ในการวิเคราะห์นี้มันมักจะเกิดขึ้นสำหรับสถานการณ์ที่เกิดขึ้นบ่อยครั้งในคอมไพเลอร์มากกว่าในซอฟต์แวร์อื่น ๆ เช่นเมื่อรวบรวมตัวดำเนินการที่อาจมีหนึ่งหรือสองตัวถูกดำเนินการ :

switch (operator->num_of_operands) {
    case 2: process_operand( operator->operand_2);
              /* FALLTHRU */

    case 1: process_operand( operator->operand_1);
    break;
}

คดีที่ผ่านมาได้รับการยอมรับอย่างกว้างขวางว่าเป็นข้อบกพร่องที่มีแม้กระทั่งการประชุมความคิดเห็นพิเศษดังที่แสดงไว้ด้านบนซึ่งบอกว่าเป็นผ้าสำลี "นี่เป็นหนึ่งใน 3% ของกรณีที่ผู้คนต้องการผ่าน"

ฉันคิดว่ามันเป็นความคิดที่ดีสำหรับ C # ที่จะต้องใช้คำสั่ง jump อย่างชัดเจนในตอนท้ายของแต่ละ case case (ในขณะที่ยังอนุญาตให้ซ้อน case case หลาย ๆ ตัวได้ ใน C # คุณยังสามารถมีกรณีหนึ่งล้มลงไปอีก - คุณเพียงแค่ต้องทำให้ผ่านชัดเจนโดยการกระโดดไปยังกรณีถัดไปโดยใช้gotoคุณเพียงแค่ต้องทำให้ฤดูใบไม้ร่วงผ่านอย่างชัดเจนโดยการกระโดดกรณีต่อไปโดยใช้

มันแย่มากที่ Java ไม่ได้มีโอกาสหยุดพักจากซีแมนทิกส์ซี

ในหลาย ๆ วิธี c เป็นเพียงส่วนต่อประสานที่สะอาดกับสำนวนประกอบมาตรฐาน เมื่อเขียนการควบคุมการไหลของการขับเคลื่อนตารางกระโดดโปรแกรมเมอร์มีทางเลือกในการล้มหรือกระโดดออกจาก "โครงสร้างการควบคุม" และการกระโดดออกต้องมีคำสั่งที่ชัดเจน

ดังนั้น c ทำสิ่งเดียวกัน ...

ในการใช้อุปกรณ์ของดัฟฟ์เห็นได้ชัดว่า:

dsend(to, from, count)
char *to, *from;
int count;
{
    int n = (count + 7) / 8;
    switch (count % 8) {
    case 0: do { *to = *from++;
    case 7:      *to = *from++;
    case 6:      *to = *from++;
    case 5:      *to = *from++;
    case 4:      *to = *from++;
    case 3:      *to = *from++;
    case 2:      *to = *from++;
    case 1:      *to = *from++;
               } while (--n > 0);
    }
}

หากกรณีถูกออกแบบมาเพื่อทำลายโดยปริยายแล้วคุณจะไม่ได้เข้าใจผิด

case 0:
case 1:
case 2:
    // all do the same thing.
    break;
case 3:
case 4:
    // do something different.
    break;
default:
    // something else entirely.

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

คำสั่ง case ในคำสั่ง switch เป็นเพียงเลเบล

เมื่อคุณเปลี่ยนค่าข้อความสั่ง switch จะข้ามไปที่ป้ายกำกับโดยมีค่าที่ตรงกัน

ซึ่งหมายความว่าจำเป็นต้องมีการหยุดพักเพื่อหลีกเลี่ยงการส่งผ่านไปยังรหัสใต้ป้ายกำกับถัดไป

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

case optionA:
    // optionA needs to do its own thing, and also B's thing.
    // Fall-through to optionB afterwards.
    // Its behaviour is a superset of B's.
case optionB:
    // optionB needs to do its own thing
    // Its behaviour is a subset of A's.
    break;
case optionC:
    // optionC is quite independent so it does its own thing.
    break;

เพื่อให้สิ่งต่าง ๆ เช่น:

switch(foo) {
case 1:
    /* stuff for case 1 only */
    if (0) {
case 2:
    /* stuff for case 2 only */
    }
    /* stuff for cases 1 and 2 */
case 3:
    /* stuff for cases 1, 2, and 3 */
}

คิดว่าcaseคำหลักเป็นgotoป้ายกำกับและมีความเป็นธรรมชาติมากขึ้น

มันกำจัดการทำสำเนารหัสเมื่อหลายกรณีจำเป็นต้องเรียกใช้รหัสเดียวกัน (หรือรหัสเดียวกันตามลำดับ)

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

ฉันบังเอิญทำงานในกรณีของการกำหนดค่าในเวกเตอร์ให้กับ structs: มันต้องทำในลักษณะที่ถ้าเวกเตอร์ข้อมูลสั้นกว่าจำนวนสมาชิกข้อมูลใน struct สมาชิกที่เหลือจะยังคงอยู่ใน ค่าเริ่มต้นของพวกเขา ในกรณีดังกล่าวการละเว้นbreakมีประโยชน์มาก

switch (nShorts)
{
case 4: frame.leadV1    = shortArray[3];
case 3: frame.leadIII   = shortArray[2];
case 2: frame.leadII    = shortArray[1];
case 1: frame.leadI     = shortArray[0]; break;
default: TS_ASSERT(false);
}

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

หากคุณมีบล็อกของรหัสต่อกรณีโดยไม่มี fall-through บางทีคุณควรลองใช้ if-elseif-else block เพราะดูจะเหมาะสมกว่า