Control Flow

Switch Statements

Master multi-way branching with switch statements. Learn case labels, fall-through behavior, break statements, and when to use switch versus if-else for cleaner, more efficient code.

Understanding Switch Statements

The switch statement provides an elegant way to handle multiple conditions based on a single value. While you could use a chain of if-else statements, switch is clearer and potentially more efficient when testing one variable against many constant values. Compilers can optimize switch statements into jump tables for fast execution regardless of the number of cases.

A switch statement evaluates an expression once, then compares the result against multiple case labels. When a matching case is found, execution begins at that point and continues until reaching a break statement or the end of the switch. This "fall-through" behavior is both powerful and error-prone, requiring careful attention to break placement.

C
#include <stdio.h>

int main(void) {
    int day = 3;
    
    switch (day) {
        case 1:
            printf("Monday\n");
            break;
        case 2:
            printf("Tuesday\n");
            break;
        case 3:
            printf("Wednesday\n");
            break;
        case 4:
            printf("Thursday\n");
            break;
        case 5:
            printf("Friday\n");
            break;
        case 6:
            printf("Saturday\n");
            break;
        case 7:
            printf("Sunday\n");
            break;
        default:
            printf("Invalid day\n");
            break;
    }
    
    return 0;
}

Switch Syntax and Rules

Switch statements have specific syntax requirements and rules. The switch expression must evaluate to an integer type (char, int, enum). Case labels must be constant expressions - you cannot use variables. Each case is a label, not a separate block, which explains the fall-through behavior if you omit break statements.

C
/* Basic syntax */
switch (expression) {
    case constant1:
        // statements
        break;
    case constant2:
        // statements
        break;
    default:
        // statements
        break;
}

/* Valid switch expressions */
switch (integer_variable) {"{ }"}       // int
switch (char_variable) {"{ }"}          // char  
switch (enum_value) {"{ }"}             // enum
switch (expression + 5) {"{ }"}         // Any integer expression
switch (function_returning_int()) {"{ }"}

/* INVALID switch expressions */
// switch (float_variable) {"{ }"}      // ERROR: Must be integer type
// switch (string) {"{ }"}              // ERROR: Cannot use strings
// switch (pointer) {"{ }"}             // ERROR: Cannot use pointers (except as integers)

/* Valid case labels (must be constants) */
case 1:          // Integer literal
case 'A':        // Character literal
case CONSTANT:   // #define or const int
case 10 + 5:     // Constant expression

/* INVALID case labels */
int x = 10;
// case x:       // ERROR: Variables not allowed
// case min..max: // ERROR: Ranges not supported in C (C++ extension)

/* default case (optional but recommended) */
switch (value) {
    case 1:
        printf("One\n");
        break;
    default:  // Handles all other values
        printf("Other\n");
        break;
}

The break Statement

Break statements are crucial in switch - they exit the switch block, preventing fall-through to subsequent cases. Without break, execution continues to the next case regardless of whether it matches. This is intentional design (not a bug), enabling useful patterns, but forgetting break is a common error.

C
/* With break (normal behavior) */
int grade = 'B';

switch (grade) {
    case 'A':
        printf("Excellent!\n");
        break;  // Exit switch
    case 'B':
        printf("Good\n");
        break;  // Exit switch
    case 'C':
        printf("Fair\n");
        break;
    default:
        printf("Try harder\n");
        break;
}

/* Without break (fall-through) */
int num = 2;

switch (num) {
    case 1:
        printf("One\n");  // No break!
    case 2:
        printf("Two\n");   // This prints
    case 3:
        printf("Three\n"); // This also prints!
    default:
        printf("Other\n"); // This also prints!
}
// Output: Two, Three, Other

/* Intentional fall-through (grouping cases) */
char ch = 'a';

switch (ch) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
        printf("Vowel\n");
        break;
    default:
        printf("Consonant\n");
        break;
}

/* Fall-through with comment (good practice) */
switch (value) {
    case 1:
        do_common();
        // FALLTHROUGH
    case 2:
        do_specific();
        break;
}

Common Switch Patterns

Switch statements excel at certain patterns - menu systems, state machines, command parsing, and categorization. These patterns demonstrate why switch is often clearer than equivalent if-else chains.

C
/* Pattern 1: Menu system */
int choice;

printf("1. New Game\n");
printf("2. Load Game\n");
printf("3. Settings\n");
printf("4. Exit\n");
scanf("%d", &choice);

switch (choice) {
    case 1:
        new_game();
        break;
    case 2:
        load_game();
        break;
    case 3:
        settings();
        break;
    case 4:
        printf("Goodbye!\n");
        exit(0);
    default:
        printf("Invalid choice\n");
        break;
}

/* Pattern 2: Character classification */
char c = 'x';

switch (c) {
    case ' ':
    case '\t':
    case '\n':
        printf("Whitespace\n");
        break;
    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
        printf("Digit\n");
        break;
    case '+': case '-': case '*': case '/':
        printf("Operator\n");
        break;
    default:
        printf("Other character\n");
        break;
}

/* Pattern 3: Day type */
int day = 6;

switch (day) {
    case 1: case 2: case 3: case 4: case 5:
        printf("Weekday\n");
        break;
    case 6: case 7:
        printf("Weekend\n");
        break;
    default:
        printf("Invalid day\n");
        break;
}

/* Pattern 4: Calculator */
char operator = '+';
int a = 10, b = 5;
int result;

switch (operator) {
    case '+':
        result = a + b;
        printf("%d + %d = %d\n", a, b, result);
        break;
    case '-':
        result = a - b;
        printf("%d - %d = %d\n", a, b, result);
        break;
    case '*':
        result = a * b;
        printf("%d * %d = %d\n", a, b, result);
        break;
    case '/':
        if (b != 0) {
            result = a / b;
            printf("%d / %d = %d\n", a, b, result);
        } else {
            printf("Division by zero!\n");
        }
        break;
    default:
        printf("Unknown operator\n");
        break;
}

/* Pattern 5: State machine */
enum State { IDLE, RUNNING, PAUSED, STOPPED };
enum State current_state = RUNNING;
char input = 'p';

switch (current_state) {
    case IDLE:
        if (input == 's') {
            current_state = RUNNING;
            printf("Started\n");
        }
        break;
    case RUNNING:
        if (input == 'p') {
            current_state = PAUSED;
            printf("Paused\n");
        } else if (input == 's') {
            current_state = STOPPED;
            printf("Stopped\n");
        }
        break;
    case PAUSED:
        if (input == 'r') {
            current_state = RUNNING;
            printf("Resumed\n");
        }
        break;
    case STOPPED:
        printf("Stopped state\n");
        break;
}

Switch vs. If-Else

Choosing between switch and if-else depends on the situation. Switch is cleaner for testing one variable against many constant values, while if-else is more flexible for complex conditions, ranges, and non-constant comparisons. Understanding the trade-offs helps you write clearer code.

C
/* Use switch when: */
// 1. Testing single variable against multiple constants
switch (command) {
    case CMD_START: start(); break;
    case CMD_STOP: stop(); break;
    case CMD_PAUSE: pause(); break;
    default: error(); break;
}

// 2. Cleaner than long if-else chain
switch (grade) {
    case 'A': printf("Excellent\n"); break;
    case 'B': printf("Good\n"); break;
    case 'C': printf("Fair\n"); break;
    case 'D': printf("Poor\n"); break;
    case 'F': printf("Fail\n"); break;
}

/* Use if-else when: */
// 1. Testing ranges
if (score >= 90) {
    grade = 'A';
} else if (score >= 80) {
    grade = 'B';
} else if (score >= 70) {
    grade = 'C';
}

// 2. Complex conditions
if (age >= 18 && has_license && !suspended) {
    printf("Can drive\n");
}

// 3. Different variables
if (x &gt; 0 && y &gt; 0) {
    printf("First quadrant\n");
}

// 4. Non-constant comparisons
if (value &gt; threshold) {
    printf("Exceeds threshold\n");
}

/* Comparison: Same logic */

// If-else version:
if (day == 1) {
    printf("Monday\n");
} else if (day == 2) {
    printf("Tuesday\n");
} else if (day == 3) {
    printf("Wednesday\n");
} else {
    printf("Other day\n");
}

// Switch version (cleaner):
switch (day) {
    case 1: printf("Monday\n"); break;
    case 2: printf("Tuesday\n"); break;
    case 3: printf("Wednesday\n"); break;
    default: printf("Other day\n"); break;
}

Advanced Switch Techniques

Switch statements support some advanced techniques that leverage their unique characteristics. Understanding these patterns expands your toolkit for solving specific problems elegantly.

C
/* Technique 1: Nested switch */
char category = 'A';
int subcategory = 2;

switch (category) {
    case 'A':
        switch (subcategory) {
            case 1: printf("A1\n"); break;
            case 2: printf("A2\n"); break;
            default: printf("A-other\n"); break;
        }
        break;
    case 'B':
        switch (subcategory) {
            case 1: printf("B1\n"); break;
            case 2: printf("B2\n"); break;
            default: printf("B-other\n"); break;
        }
        break;
}

/* Technique 2: Duff's Device (advanced, for optimization) */
// Copies count bytes, unrolling loop
void duff_memcpy(char *to, char *from, int count) {
    int n = (count + 7) / 8;
    switch (count % 8) {
        case 0: do { *to++ = *from++;
        case 7:      *to++ = *from++;
        case 6:      *to++ = *from++;
        case 5:      *to++ = *from++;
        case 4:      *to++ = *from++;
        case 3:      *to++ = *from++;
        case 2:      *to++ = *from++;
        case 1:      *to++ = *from++;
                } while (--n &gt; 0);
    }
}

/* Technique 3: Using enums for clarity */
enum Command {
    CMD_NONE,
    CMD_START,
    CMD_STOP,
    CMD_PAUSE
};

enum Command cmd = CMD_START;

switch (cmd) {
    case CMD_NONE:
        printf("No command\n");
        break;
    case CMD_START:
        printf("Starting\n");
        break;
    case CMD_STOP:
        printf("Stopping\n");
        break;
    case CMD_PAUSE:
        printf("Pausing\n");
        break;
}

/* Technique 4: Computed cases */
#define BASE 100

switch (value) {
    case BASE + 0:
        printf("100\n");
        break;
    case BASE + 1:
        printf("101\n");
        break;
    case BASE + 2:
        printf("102\n");
        break;
}

Common Pitfalls

Switch statements have specific pitfalls that catch programmers of all skill levels. Being aware of these helps you avoid bugs and write correct switch code.

C
/* Pitfall 1: Forgetting break */
int x = 2;

switch (x) {
    case 1:
        printf("One\n");
    case 2:
        printf("Two\n");  // Prints this
    case 3:
        printf("Three\n");  // And this!
    default:
        printf("Other\n");  // And this!
}

/* Pitfall 2: Variable declarations after case */
switch (x) {
    case 1:
        int y = 10;  // DANGEROUS: Skipped if x != 1
        printf("%d\n", y);
        break;
    case 2:
        printf("%d\n", y);  // Uses uninitialized y!
        break;
}

/* Solution: Use block */
switch (x) {
    case 1: {
        int y = 10;
        printf("%d\n", y);
        break;
    }
    case 2: {
        // y doesn't exist here
        break;
    }
}

/* Pitfall 3: Non-constant case values */
int min = 10;
// switch (x) {
//     case min:  // ERROR: Not a constant!
//         break;
// }

/* Solution: Use #define or enum */
#define MIN 10
switch (x) {
    case MIN:  // OK
        break;
}

/* Pitfall 4: Missing default */
switch (user_input) {
    case 1:
        process_1();
        break;
    case 2:
        process_2();
        break;
    // What if user_input is 3? Silently does nothing!
}

/* Better: Always include default */
switch (user_input) {
    case 1:
        process_1();
        break;
    case 2:
        process_2();
        break;
    default:
        printf("Invalid input\n");
        break;
}

/* Pitfall 5: Duplicate case labels */
// switch (x) {
//     case 1:
//         break;
//     case 1:  // ERROR: Duplicate!
//         break;
// }

/* Pitfall 6: Using switch with wrong type */
// float f = 1.5;
// switch (f) {  // ERROR: Must be integer type
//     case 1.0:
//         break;
// }

/* Convert to int if needed */
switch ((int)f) {
    case 1:
        printf("Around 1\n");
        break;
    case 2:
        printf("Around 2\n");
        break;
}

Summary & What's Next

Key Takeaways:

âœ… Switch tests one value against multiple constants
âœ… Case labels must be constant expressions
âœ… Break prevents fall-through to next case
âœ… Default handles values not matched by any case
âœ… Switch only works with integer types (char, int, enum)
âœ… Fall-through can be intentional for grouping cases
âœ… Use switch for clarity when testing one variable
âœ… Use if-else for ranges, complex conditions, or non-constants

What's Next?

Let's learn about goto and labels (and why to avoid them)!

Next: Goto & Labels â†’