> ## Documentation Index > Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt > Use this file to discover all available pages before exploring further. # C++ Switch Statement A control flow construct that evaluates a given condition and transfers execution to a specific labeled statement based on the condition's value. It operates via a jump table or binary search at the assembly level, providing an optimized execution path compared to sequential `if-else if` evaluations. ## Syntax ```text theme={"dark"} switch (init-statement(optional) condition) { case constant_expression_1: // Statements executed if condition == constant_expression_1 break; case constant_expression_2: // Statements executed if condition == constant_expression_2 break; default: // Statements executed if no case matches break; } ``` *(Note: The `init-statement` is an optional feature introduced in C++17 and must end with a semicolon. The syntax block above uses plain text to represent the grammar template).* ## Technical Constraints **1. Condition Type Requirements** The `condition` can be either an expression or a declaration of a single non-static variable with a brace-or-equals initializer. The evaluated result of the expression, or the value of the declared variable, must be of an integral type (e.g., `int`, `char`, `short`, `long`, `bool`), an enumeration type (`enum` or `enum class`), or a class type that is contextually implicitly convertible to exactly one integral or enumeration type. Floating-point types (`float`, `double`) and string literals/objects are strictly prohibited. **2. Case Label Requirements** Every `case` label must evaluate to a compile-time constant expression. This includes literals, `constexpr` variables, and `const` integral variables initialized with constant expressions. All case labels within a single `switch` statement must have unique values after implicit conversion to the **adjusted type** of the condition (the type after all applicable conversions and promotions). This distinction is critical for scoped enumerations (`enum class`), which do not undergo integral promotion. **3. The Default Label** The `default` label is optional and acts as a catch-all execution path if no `case` constant matches the evaluated condition. A `switch` statement may contain at most one `default` label, which can be positioned anywhere within the switch block, though it is conventionally placed at the end. ## Execution Flow and Fallthrough When the `switch` condition is evaluated, control jumps directly to the matching `case` label. Execution then proceeds sequentially, statement by statement. If a `break` statement is not encountered, execution will "fall through" into subsequent `case` or `default` blocks, ignoring their labels entirely. To explicitly indicate to the compiler that a fallthrough is intentional and to suppress compiler warnings, C++17 introduced the `[[fallthrough]]` attribute. ```cpp theme={"dark"} #include int main() { int value = 1; switch (value) { case 1: std::cout << "Executing Step One\n"; [[fallthrough]]; // C++17 attribute explicitly allowing fallthrough case 2: std::cout << "Executing Step Two\n"; break; // Terminates the switch block } return 0; } ``` ## Scoping and Variable Initialization The entire body of a `switch` statement constitutes a single block scope. This introduces specific rules regarding variable declarations: **Jumping Over Initialization:** It is ill-formed in C++ to transfer control bypassing the initialization of a variable with **automatic storage duration** (local variables) that has an explicit initializer or a non-trivial constructor/destructor. If such a variable is initialized inside a `case`, and a subsequent `case` is executed, control would bypass the initialization. To resolve this, variables initialized inside a `case` must be enclosed in their own nested block scope. Conversely, it is perfectly valid to jump over the initialization of variables with **static storage duration**, as their initialization is guaranteed to be handled safely by the runtime upon first execution, regardless of control flow jumps. ```cpp theme={"dark"} #include int main() { int value = 2; switch (value) { case 1: // Valid: If value == 2 or 3, control jumps over this declaration. // Bypassing the initialization of variables with static storage duration is permitted. static int y = 20; std::cout << "y is " << y << '\n'; break; case 2: { // Valid: Automatic variable scope is restricted to this nested block. // If value == 3, control jumps over this entire block, safely avoiding the bypassed initialization rule. int x = 10; std::cout << "x is " << x << '\n'; break; } case 3: std::cout << "Executing Step Three\n"; break; } return 0; } ``` **Condition Declarations vs. C++17 Initialization Statement:** Prior to C++17, it was already possible to declare and initialize a variable directly in the `condition` (e.g., `switch (int x = getValue())`). However, the switch logic was restricted to evaluating that specific variable. C++17 introduced the `init-statement`, allowing developers to declare and initialize a variable *and* provide a separate condition expression. Variables declared in either the `init-statement` or the `condition` are scoped strictly to the `switch` statement (including all `case` blocks) and are destroyed when the `switch` terminates. ```cpp theme={"dark"} #include struct Result { int statusCode; }; Result getResult() { return {200}; } int main() { // C++17: Separate init-statement and condition switch (Result res = getResult(); res.statusCode) { case 200: // 'res' is fully accessible here, but the switch evaluated 'res.statusCode' std::cout << "Success. Status Code: " << res.statusCode << '\n'; break; case 404: std::cout << "Not Found. Status Code: " << res.statusCode << '\n'; break; } return 0; } ```

Tired of Poor C++ Skills? Fix That With Deep Grasping! Learn More