Control Flow: Conditional Statements (if, else, switch)

Using `if`, `else`, and `switch` statements to control the flow of execution based on conditions.

⬅ Previous Next ➡

C Programming: Control Flow - switch Statement

Control Flow: Conditional Statements (switch)

In C programming, control flow refers to the order in which statements are executed in a program. Conditional statements allow us to execute different blocks of code based on certain conditions. The switch statement is a multi-way decision statement that tests whether an expression matches one of several constant integer values (cases) and branches accordingly.

Using the `switch` statement to efficiently handle multiple choices

The switch statement provides a cleaner and often more efficient way to handle multiple choices compared to using nested if-else if-else statements, especially when you're comparing a single variable against multiple constant values. The basic syntax of the switch statement is as follows:

 switch (expression) {
    case constant1:
        // Statements to execute if expression == constant1
        break;
    case constant2:
        // Statements to execute if expression == constant2
        break;
    // ... more cases
    default:
        // Statements to execute if no case matches the expression
        break;
}

Explanation:

expression: This is the variable or expression whose value will be compared against the case constants. It must evaluate to an integer (int, char, short, long, enum). Floating-point types (float, double) are not allowed.
case constant1:, case constant2:, ...: Each case represents a specific value. The constant must be a constant expression (e.g., a literal value or a #define constant). If the value of expression matches the constant, the statements following that case are executed.
break;: This statement is crucial. When a case matches, the statements following that case are executed *until* a break statement is encountered. If you omit the break, execution will "fall through" to the next case, even if its value doesn't match the expression. This is sometimes intentional but is more often a source of bugs.
default:: The default case is optional. If none of the case constants match the expression, the statements following the default case are executed. It's good practice to include a default case to handle unexpected or invalid input.

Example:

 #include <stdio.h>

int main() {
    int grade = 85;

    switch (grade / 10) {
        case 10: // grade 100
        case 9:  // grades 90-99
            printf("Excellent!\n");
            break;
        case 8:  // grades 80-89
            printf("Very good!\n");
            break;
        case 7:  // grades 70-79
            printf("Good\n");
            break;
        case 6:  // grades 60-69
            printf("Pass\n");
            break;
        default: // grades below 60
            printf("Fail\n");
            break;
    }

    return 0;
}

In this example, the switch statement determines a student's performance based on their numerical grade. Notice the grade / 10 which effectively groups grades into ranges (90-100, 80-89, etc.). Also, cases 10 and 9 are grouped together allowing code to be shared for different value ranges. The output will be "Very good!".

Advantages of using switch:

Readability:switch statements can be more readable than nested if-else if-else statements, especially when dealing with multiple choices.
Efficiency: In some cases, compilers can optimize switch statements for faster execution, especially when the number of cases is large. This optimization is often achieved through a jump table, which allows the program to jump directly to the correct case without evaluating each condition sequentially.

Disadvantages of using switch:

Limited to Integer Types: The switch statement only works with integer types (int, char, etc.). You cannot use it with floating-point types or strings directly.
Requires Constant Cases: The case labels must be constant expressions. You cannot use variables or expressions that are evaluated at runtime.
Fall-through behavior: The fall-through behavior (requiring break statements) can be a source of errors if not handled carefully. Forgetting a break can lead to unexpected results.