Switch with Initializer

The C++17 switch with initializer is a control flow construct that permits the declaration and initialization of a local variable directly within the switch statement’s evaluation clause. This mechanism restricts the lexical scope of the initialized variable strictly to the body of the switch block, preventing scope leakage and enforcing tighter variable lifecycle management.

Syntax

switch (init-statement condition) {
    case constant-expression:
        // statements
        break;
    default:
        // statements
        break;
}

Mechanics and Evaluation Order

1. init-statement: This executes exactly once before the condition is evaluated. In C++17, it must be an expression statement or a simple declaration (which includes structured bindings, but excludes alias declarations until C++23). In C++ grammar, an init-statement inherently includes its own terminating semicolon, which is why no explicit semicolon separates it from the condition in the formal syntax.
2. condition: Following the initialization, this clause is evaluated to determine control flow. The condition can be either an expression or a declaration with a brace-or-equals initializer (e.g., switch (int a = 1; int b = compute(a))). The condition must yield an integral type, an enumeration type, or a class type that possesses an unambiguous implicit conversion to an integral or enumeration type.

Scope Rules

Variables declared within the init-statement (as well as any variables declared within a declaration-based condition) are injected into the scope of the switch statement. This scope encompasses:

• The condition clause itself.
• The entire compound statement forming the body of the switch (all case and default labels).

The variables are automatically destroyed when execution exits the switch block, whether via a break statement, a return, or by reaching the end of the block.

Code Examples

// 'val' is declared and initialized in the init-statement (which includes the semicolon).
// The condition is an expression evaluating 'val' to determine the execution path.
switch (int val = compute_value(); val) {
    case 1:
        // 'val' is in scope and evaluates to 1
        break;
    case 2:
        // 'val' is in scope and evaluates to 2
        break;
    default:
        // 'val' is in scope for any other integer value
        break;
}
// Compilation error: 'val' is out of scope here.

// 'a' is declared in the init-statement.
// 'b' is declared and initialized in the condition clause.
switch (int a = 1; int b = compute(a)) {
    case 1:
        // Both 'a' and 'b' are in scope
        break;
    default:
        break;
}

Technical Characteristics

• Decoupled Types: The type of the variable declared in the init-statement does not strictly need to match the type evaluated in the condition, provided the condition itself resolves to a valid switch type (integral/enum).
• Multiple Declarations: Similar to the initialization clause of a for loop, the init-statement can declare multiple variables of the same base type using a comma-separated list (e.g., switch (int a = 1, b = 2; a + b)).
• Shadowing: If a variable declared in the init-statement or condition shares a name with a variable in the enclosing outer scope, the outer variable is shadowed (hidden) for the duration of the switch block.

Master C++ with Deep Grasping Methodology!

Learn More