> ## 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 Case Label A `case` label is a specialized jump target used exclusively within the body of a `switch` statement to direct control flow. It specifies an integer constant expression that the compiler compares against the evaluated result of the `switch` statement's controlling expression. When a match occurs, execution jumps directly to the statement immediately following the label. ```c theme={"dark"} case constant-expression: statement ``` ## Technical Constraints * **Constant Expression Requirement:** The expression following the `case` keyword must evaluate to an integer type (`int`, `char`, `enum`) at compile time. Variables, floating-point values, string literals, and function calls are strictly prohibited. * **Uniqueness:** Every `case` label within a single `switch` block must evaluate to a unique integer value. Duplicate values will trigger a compilation error. * **Type Promotion:** According to the C standard, integer promotions are first performed on the `switch` statement's controlling expression. Subsequently, each `case` constant expression is converted to the promoted type of the controlling expression before the comparison occurs. * **Scope and Placement:** `case` labels have no lexical scope of their own. They must be enclosed within a `switch` statement, but C syntax permits them to be nested within other control structures inside that `switch` (a mechanic famously exploited by Duff's Device). ## Execution Mechanics A `case` label acts purely as an entry point; it does not dictate an exit point. Once control jumps to a `case` label, execution proceeds sequentially. It will bypass subsequent `case` and `default` labels, executing their associated statements in a behavior known as "fallthrough." To terminate the execution path, an explicit jump statement (such as `break`, `return`, or `goto`) must be invoked. ```c theme={"dark"} switch (x) { case 1: /* Execution starts here if x == 1 */ x = 10; /* Falls through to case 2 unless a break is present */ case 2: x = 20; break; } ``` ## Lexical Rules Regarding Declarations Historically in C (prior to C23), a label can only precede a statement, not a declaration. If a variable must be declared immediately following a `case` label, the execution path must be wrapped in a compound statement (a block) to satisfy the grammar rules. This compound block approach is universally valid across all versions of C. Alternatively, an empty statement (`;`) can be placed immediately after the colon to satisfy the label requirement. However, because C89/C90 strictly requires all declarations to precede statements within a block, this empty statement workaround is only valid in C99 and later. ```c theme={"dark"} switch (x) { case 1: { /* Universally valid (C89+): Declaration inside a compound statement */ int y = 5; x = y; break; } case 2: ; /* Valid only in C99+: Empty statement precedes declaration */ int z = 10; x = z; break; } ```

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