switch

Keyword: switch Statement

The switch statement in C++ is a control flow construct used for multi-way branching. It provides an efficient way to execute different code blocks based on the value of a single expression, often serving as an alternative to multiple if-else statements.

Key Characteristics

• Allows selection among multiple code blocks based on a single expression
• The expression must evaluate to an integral type or an enumeration
• Each case is labeled with a constant expression
• Execution flows through cases unless explicitly broken
• Supports a default case for handling unmatched values
• More efficient than multiple if-else statements for many cases
• Cases must be compile-time constants

Example 1: Basic Usage: Day of the Week

#include <iostream>

int main() {
    int dayNumber;
    std::cout << "Enter a day number (1-7): ";
    std::cin >> dayNumber;

    switch (dayNumber) {
        case 1:
            std::cout << "Monday";
            break;
        case 2:
            std::cout << "Tuesday";
            break;
        case 3:
            std::cout << "Wednesday";
            break;
        case 4:
            std::cout << "Thursday";
            break;
        case 5:
            std::cout << "Friday";
            break;
        case 6:
            std::cout << "Saturday";
            break;
        case 7:
            std::cout << "Sunday";
            break;
        default:
            std::cout << "Invalid day number";
    }

    std::cout << std::endl;
    return 0;
}

Explanation:

• The switch statement evaluates the dayNumber expression.
• Each case represents a possible value of dayNumber.
• The break statement prevents fall-through to the next case.
• The default case handles any value not explicitly covered by the other cases.

2. Fall-through Behavior

#include <iostream>

int main() {
    char grade;
    std::cout << "Enter your grade (A, B, C, D, or F): ";
    std::cin >> grade;

    switch (grade) {
        case 'A':
        case 'B':
        case 'C':
            std::cout << "You passed!";
            break;
        case 'D':
            std::cout << "You barely passed.";
            break;
        case 'F':
            std::cout << "You failed.";
            break;
        default:
            std::cout << "Invalid grade entered.";
    }

    std::cout << std::endl;
    return 0;
}

Explanation:

• This example demonstrates intentional fall-through behavior.
• Cases 'A', 'B', and 'C' all lead to the same output without using break.
• This technique is useful when multiple cases should execute the same code.
• The break statement is still used to prevent unintended fall-through.

3. Enum Class with Switch

#include <iostream>

enum class Color { Red, Green, Blue, Yellow };

int main() {
    Color selectedColor = Color::Blue;

    switch (selectedColor) {
        case Color::Red:
            std::cout << "You selected Red";
            break;
        case Color::Green:
            std::cout << "You selected Green";
            break;
        case Color::Blue:
            std::cout << "You selected Blue";
            break;
        case Color::Yellow:
            std::cout << "You selected Yellow";
            break;
    }

    std::cout << std::endl;
    return 0;
}

Explanation:

• This example uses an enum class with switch.
• Enum classes provide type safety and avoid name conflicts.
• Each enum value is a separate case in the switch statement.
• No default case is needed if all enum values are covered.

Example 4: Switch with Initialization (C++17)

#include <iostream>
#include <string>

int main() {
    std::cout << "Enter a fruit name: ";
    std::string fruit;
    std::cin >> fruit;

    switch (int length = fruit.length(); length) {
        case 5:
            std::cout << "The fruit name has 5 letters. Is it 'Apple'?";
            break;
        case 6:
            std::cout << "The fruit name has 6 letters. Is it 'Orange'?";
            break;
        case 7:
            std::cout << "The fruit name has 7 letters. Is it 'Banana'?";
            break;
        default:
            std::cout << "The fruit name has " << length << " letters.";
    }

    std::cout << std::endl;
    return 0;
}

Explanation:

• This C++17 feature allows an initialization statement in the switch.
• int length = fruit.length(); is executed before the switch comparison.
• The initialized variable (length) is then used in the switch expression.
• This feature can make the code more concise and localize variable scope.

Additional Considerations

1. Performance: switch can be more efficient than multiple if-else statements, especially for a large number of cases.

2. Compile-time Constants: Case labels must be compile-time constants, not variables.

3. Default Case: It's a good practice to include a default case to handle unexpected values.

4. Scoping: Each case in a switch statement does not create a new scope. Use blocks {} if you need to declare variables within a case.

Summary

The switch statement in C++ is a powerful control flow construct for multi-way branching based on a single expression. It offers a clean and efficient alternative to multiple if-else statements, especially when dealing with discrete values like integers or enumerations. Key features include the ability to handle multiple cases, intentional fall-through behavior, and a default case for unmatched values. While switch statements are limited to integral types and enumerations, they provide better readability and potentially better performance for multiple condition checking. Modern C++ (C++17 and later) has enhanced the switch statement with initialization capabilities, further improving its utility. When using switch, it's important to remember to use break statements to prevent unintended fall-through, consider all possible cases including a default, and be aware of the compile-time constant requirement for case labels.