为什么C++中switch语句的case必须加break？

1. First, reproduce the classic pit of missing break

#include <iostream>
using namespace std;

int main() {
    int score = 90;
    char grade;

    switch(score / 10) {
        case 10:
        case 9:
            grade = 'A';
        case 8:
            grade = 'B';
        case 7:
            grade = 'C';
        case 6:
            grade = 'D';
        default:
            grade = 'F';
    }

    cout << "Grade: " << grade << endl; // Guess what the output is?
    return 0;
}

Grade: F

switch(score / 10) {
    case 10:
    case 9:
        grade = 'A';
        break; // Jump out of switch after execution
    case 8:
        grade = 'B';
        break;
    case 7:
        grade = 'C';
        break;
    case 6:
        grade = 'D';
        break;
    default:
        grade = 'F';
}
// Output: Grade: A

2. Core mechanism: What is switch penetration?

After the switch matches a successful case tag, it will start executing from the code corresponding to the case, and will not automatically jump out of the switch block until it encounters break, return, throw or the end of the switch block. Even if the subsequent case conditions do not match, it will continue to execute.

3. Is penetration a historical bug? No, it’s a deliberate design!

3.1 Original design intention: Simplify multi-case shared logic

int get_month_days(int year, int month) {
    switch(month) {
        // 7 months with 31 days share the same return logic
        case 1: case 3: case 5: case 7: case 8: case 10: case 12:
            return 31; // return will jump out of the function directly, no need for break
        // 4 months with 30 days share logic
        case 4: case 6: case 9: case 11:
            return 30;
        // Special handling for February
        case 2:
            return (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0) ? 29 : 28;
        default:
            return -1; // Invalid month
    }
}

3.2 Underlying principle: Switch is essentially a jump table

void test_switch(int x) {
    switch(x) {
        case 1:
            cout << "Case 1" << endl;
            break;
        case 2:
            cout << "Case 2" << endl;
            break;
        default:
            cout << "Default" << endl;
    }
}

test_switch(int):
        cmp     edi, 2
        ja      .L4                 ; If x>2, jump to default branch
        jmp     [QWORD PTR .L8[0+rdi*8]] ; Jump to the corresponding entry according to the jump table
.L8:                            ; Jump table: stores the entry address of each case
        .quad   .L4                 ; x=0 corresponds to default
        .quad   .L5                 ; x=1 corresponds to case 1 entry
        .quad   .L6                 ; x=2 corresponds to case 2 entry
.L5:                             ; case 1 entry
        call    cout << "Case 1" << endl
        jmp     .L1                 ; The jump instruction corresponding to break, jump out of switch
.L6:                             ; case 2 entry
        call    cout << "Case 2" << endl
        jmp     .L1                 ; The jump instruction corresponding to break
.L4:                             ; default entry
        call    cout << "Default" << endl
.L1:                             ; End of switch block
        ret

1. The switch first queries the jump table according to the value of x and jumps directly to the corresponding entry address
2. The break keyword corresponds to a jmp instruction at the assembly level, which is used to jump to the end of the switch block
3. If there is no break, after executing the code of case 1, it will directly “fall through” to the code of case 2, because there is no jump instruction to block it.

4. Hidden bugs caused by accidental penetration

4.1 Common pit 1: Missing break in nested logic

enum State { INIT, RUNNING, PAUSED, FINISHED };

void handle_state(State s) {
    switch(s) {
        case INIT:
            init_system();
            if (init_success()) {
                s = RUNNING;
                // Oops! Forgot to add break here
            } else {
                log_error("Init failed");
                break;
            }
            // No break, will penetrate to RUNNING branch
        case RUNNING:
            run_task();
            break;
        // Other cases omitted...
    }
}

4.2 Common pit 2: Implicit penetration leads to subsequent maintenance errors

// Original code: Both 1 and 2 execute the same logic
switch(x) {
    case 1:
        // Later maintainers added a line of code here, thinking it would only be executed when x=1
        // But actually x=2 will also execute this line of code
    case 2:
        cout << "1 or 2" << endl;
        break;
}

5. Modern C++ Penetration Specification and Pit Avoidance Guide

5.1 Explicitly mark intentional penetration

• Before C++17: Use standardized comments such as /* fallthrough */ or /* FALLTHROUGH */, and most compilers will recognize this comment and will not warn of missing break.
• C++17 and above: Use the standard attribute [[fallthrough]], which is a cross-platform standard writing method, explicitly telling the compiler that penetration is expected, and no warning will be issued.

switch(x) {
    case 1:
        cout << "Process case 1" << endl;
        [[fallthrough]]; // Explicitly mark penetration, no warning
    case 2:
        cout << "Process case 1 and 2" << endl;
        break;
    default:
        cout << "Other" << endl;
}

5.2 Enable compiler warnings to block problems at compile time

• GCC/Clang: Add -Wimplicit-fallthrough parameter, which is included in -Wall in higher versions. Add -Werror to treat all warnings as errors.
• Visual Studio: Enable C4468 warning.

5.3 Coding specification constraints

1. Each case must have a break, return, throw or [[fallthrough]] mark, no exception.
2. If the code in the case is long, it is recommended to wrap it with curly braces to form an independent scope, avoid variable definition conflicts, and make the structure clearer:
   cpp

   switch(x) {
       case 1: {
           int temp = 0; // Local variables in the case need to be wrapped in curly braces
           process(temp);
           break;
       }
       case 2:
           // ...
   }
   

3. Try to avoid complex penetration logic. If there is a lot of shared code, it is better to extract it into a public function than to use penetration, which is more readable.

5.4 Replace switch with modern features in appropriate scenarios

• Use polymorphism to handle different state logic, avoid huge switch blocks
• Use C++17 std::variant + std::visit to implement type-safe pattern matching
• Use a finite state machine library to manage state transitions

6. Extended discussion: Is the penetration mechanism a good design?

• Go language: switch defaults to no penetration, and you must explicitly add the fallthrough keyword if you need to penetrate
• Rust: match expression (similar to switch) has no penetration at all, each branch will automatically jump out, and it is mandatory to exhaust all branches, which is safer
• Java 12+: Introduced switch expression, using -> to define branches, default no penetration, no need to add break

7. Summary and practical suggestions

1. The break after the C++ switch case is not “must add”: it is necessary to add break in most business scenarios to avoid accidental penetration; it can be omitted when multiple cases share logic, but it must be explicitly marked.
2. The penetration mechanism is not a bug, but a historical design feature, which is used to simplify the scenario where multiple cases share code, and reasonable use can make the code more concise.
3. Deliberate penetration must be explicitly marked: C++17 and above recommend using [[fallthrough]], and below C++17 use standard fallthrough comments, and implicit penetration is strictly prohibited.
4. Enable compiler implicit penetration warning, treat warning as error, and block missing break problems at compile time.
5. For complex multi-branch scenarios, you can consider using polymorphism, std::visit and other modern features to replace switch to improve code security and readability.