C++ switch Statement: Cases, Fall-Through, and break

What switch Is For

A switch compares one value against a list of fixed options and runs the branch that matches. When you catch yourself writing a long if/else if chain that keeps testing the same variable against different constants, a switch expresses that intent more clearly - and often compiles to a faster jump table.

It only does equality checks against compile-time constants on an integer-like value. It cannot test ranges, compare strings, or combine conditions. For any of those, stay with if/else.

The Basic switch

You give switch a value, then list case labels for the values you care about. Each branch ends with break:

#include <iostream>
using namespace std;

int main() {
    int day = 3;

    switch (day) {
        case 1:
            cout << "Monday" << endl;
            break;
        case 2:
            cout << "Tuesday" << endl;
            break;
        case 3:
            cout << "Wednesday" << endl;
            break;
        default:
            cout << "Some other day" << endl;
            break;
    }

    return 0;
}

The value 3 matches case 3:, so "Wednesday" prints and break jumps out of the switch. The default branch is the catch-all - it runs when no case matches. It is optional, but include it unless you are certain every value is handled.

Note the case labels are bare constants followed by a colon, not conditions. You write case 3:, never case day == 3:.

break and Fall-Through

This is the single most important switch gotcha in C++. After a case matches, execution does not stop at the next case - it keeps running straight through until it hits a break or the closing brace. Watch what happens when the break statements are missing:

#include <iostream>
using namespace std;

int main() {
    int level = 1;

    switch (level) {
        case 1:
            cout << "one" << endl;
        case 2:
            cout << "two" << endl;
        case 3:
            cout << "three" << endl;
        default:
            cout << "done" << endl;
    }

    return 0;
}

You might expect just "one". Instead all four lines print: matching case 1: enters the switch there and then falls through every label below it. Add a break; after each branch and you get the single line you wanted. Forgetting a break is the classic source of "why is my switch running too much code?" bugs.

Intentional Fall-Through to Group Cases

Fall-through is not always a mistake - it is the idiomatic way to make several cases share one body. Leave the cases empty (no statements, no break) and they all flow into the next block:

#include <iostream>
using namespace std;

int main() {
    char grade = 'B';

    switch (grade) {
        case 'A':
        case 'B':
        case 'C':
            cout << "Pass" << endl;
            break;
        case 'D':
        case 'F':
            cout << "Fail" << endl;
            break;
        default:
            cout << "Invalid grade" << endl;
    }

    return 0;
}

'A', 'B', and 'C' all land on the same "Pass" line because the first two cases are empty and fall through into the third. This is clean and intended. When you do mean to fall through after running some code, document it with a comment - or in C++17 and later, the [[fallthrough]]; attribute, which tells the compiler "yes, I meant this" and silences fall-through warnings.

Switching on enums

switch pairs naturally with enums, since an enum is exactly "one of a fixed set of values". Compilers can also warn you if you forget to handle one of the enumerators:

#include <iostream>
using namespace std;

enum class Direction { North, East, South, West };

int main() {
    Direction d = Direction::East;

    switch (d) {
        case Direction::North:
            cout << "Heading up" << endl;
            break;
        case Direction::East:
            cout << "Heading right" << endl;
            break;
        case Direction::South:
            cout << "Heading down" << endl;
            break;
        case Direction::West:
            cout << "Heading left" << endl;
            break;
    }

    return 0;
}

With a scoped enum class you must qualify each label (Direction::East). Because every enumerator is covered, no default is needed - and many compilers will warn if you later add a fifth direction and forget to add its case. That compiler help is a big reason to prefer switch over if/else chains for enums.

A Gotcha: Declarations Inside a case

You cannot declare a variable with an initializer in one case and have it visible across the other cases without scoping it. This is a common compile error:

switch (x) {
    case 1:
        int n = 10;   // error: jump to case 2 bypasses this initialization
        cout << n;
        break;
    case 2:
        cout << "two";
        break;
}

The compiler rejects it because falling into case 2: would skip past the initialization of n while n is still in scope. The fix is to wrap the case body in its own braces, giving the variable a block of its own:

#include <iostream>
using namespace std;

int main() {
    int x = 1;

    switch (x) {
        case 1: {
            int n = 10;   // now scoped to this block - fine
            cout << n << endl;
            break;
        }
        case 2:
            cout << "two" << endl;
            break;
    }

    return 0;
}

Whenever a case needs its own local variable, give it braces. It also keeps the variable from leaking into the cases below it.

Next: for-loop

switch and if let your program choose which code to run once. But plenty of work means doing the same thing many times - counting, iterating over a list, repeating until a condition changes. The for loop is the workhorse for that, and it is the next page.