Switch Case C++

Syntax of switch Statement in C++

The syntax of a switch statement in C++ is the set of rules that outlines how you should write and structure it in your code. 

Here's what the basic syntax looks like:

switch (expression) {
    case constant1:
        // code block to be executed if expression equals constant1
        break; // stops the switch from running more code
    case constant2:
        // code block to be executed if expression equals constant2
        break; // again, stops the switch
    // You can have any number of case statements
    default: 
        // code block to be executed if expression doesn't match any case
}

• switch: This keyword starts the switch statement.
   
• expression: This is the part where you put the variable you're checking. It's evaluated once, and its value is compared with the values of each case.
   
• case: This keyword is followed by a constant value to compare with the expression. If the expression matches the constant, the code right after this case runs.
   
• break: This keyword stops the switch statement from executing more code. Without it, C++ might run code from the next case too, which you might not want.
   
• default: This part is optional. It runs if none of the cases match the expression's value. It's like a safety net to catch any values you didn't think of.
   

When writing a switch statement, you need to make sure you're following this structure so your code runs the way you want it to. It's all about making sure your code knows what to do with the variable you're checking.

Example of Switch Statement

Now that we know about the syntax of a switch statement, let's look at a simple example where we have used switch statement.

Imagine we have a simple program that takes a number from the user and tells them what day of the week it corresponds to, with Sunday being 1, Monday being 2, and so on up to Saturday, which is 7. If the user enters a number outside this range, the program will tell them it's an invalid number.

Here's how we can write this program using a switch statement:

• C++

C++

#include <iostream>
using namespace std;

int main() {
    int dayNumber;
    cout << "Enter a number (1-7): ";
    cin >> dayNumber; // Getting the day number from the user

    switch (dayNumber) {
        case 1:
            cout << "Sunday";
            break;
        case 2:
            cout << "Monday";
            break;
        case 3:
            cout << "Tuesday";
            break;
        case 4:
            cout << "Wednesday";
            break;
        case 5:
            cout << "Thursday";
            break;
        case 6:
            cout << "Friday";
            break;
        case 7:
            cout << "Saturday";
            break;
        default:
            cout << "Invalid number! Please enter a number between 1 and 7.";
    }

    return 0;
}

You can also try this code with Online C++ Compiler

Run Code

Output

Enter a number (1-7): 5
Thursday

In this program:

• We start by including the iostream library to use input and output functions.
   
• We declare an int variable named dayNumber to store the number entered by the user.
   
• We prompt the user to enter a number between 1 and 7 and store their input in dayNumber.
   
• We use a switch statement to check the value of dayNumber. For each case from 1 to 7, we print the corresponding day of the week.
   
• If the user enters a number that's not between 1 and 7, the default case runs, telling them it's an invalid number.

This example demonstrates how to use a switch statement to handle multiple specific cases based on a single variable's value. It makes the code cleaner and more straightforward than using multiple if-else statements for each case.

Rules of the Switch Case Statement in C++

When working with switch case statements in C++, there are some important rules you need to follow to make sure your code runs smoothly and does exactly what you expect it to do. Understanding these rules will help you avoid common pitfalls and ensure your switch statements are effective and error-free.

Integer or Enumerated Types Only

The expression used in a switch statement must result in an integer or an enumerated type. This means you can't use floating-point types or strings directly in the switch expression.

Unique Case Values

Each case label must be unique within the same switch block. Duplicate case values are not allowed because it would create ambiguity in which block of code should be executed.

Constant Expressions for Cases

The values in case statements must be constant expressions. This means the value must be known at compile-time, so you can't use variables or runtime expressions as case labels.

Break Statement

While the break statement is not mandatory, it's commonly used to terminate the switch case block once a matching case is executed. Without a break, the program will continue executing the following cases until it hits a break or reaches the end of the switch statement, which might lead to unexpected behavior.

Default Case

The default case is optional but recommended. It serves as a catch-all for any values that do not match any of the specified case labels. Including a default case ensures that your switch statement always has a defined behavior for unexpected values.

Scope of Variables

If you declare variables inside a switch case, make sure to enclose the case block in curly braces {} to create a local scope. Without these braces, you might encounter errors due to variables being declared in the same scope as the case labels.

Sequential Execution

If a case matches and there's no break statement, the switch case will execute all subsequent statements until it finds a break, even if those statements belong to other case labels. This is known as "fall-through" behavior and can be useful or harmful depending on how you intend to use it.

Flowchart of Switch Statement in C++

Understanding how a switch statement works in C++ can be made easier with the help of a flowchart. A flowchart is a diagram that shows the steps of a process or a system from start to finish. For the switch statement, a flowchart helps visualize how the program decides which block of code to execute based on the value of a variable.

Here's a simple breakdown of the flowchart for a switch statement:
 

Start

This is where the process begins. It's the point in your program where the switch statement is about to be executed.

Evaluate Expression

The next step is to evaluate the expression inside the switch statement. This expression is usually a variable, and its value determines which path the flowchart (and thus the program) will take next.

Match Case

After the expression is evaluated, the flowchart splits into different branches, each representing a case in the switch statement. The program follows the branch that matches the value of the expression.

Execute Case Block

Once the matching case is found, the code block associated with that case is executed. If no case matches the expression's value, the flowchart directs the program to the default case, if one is provided.

Break (Optional)

If a break statement is encountered, the program exits the switch statement and continues with the rest of the code that follows it. If there's no break, the program may continue executing the next case block, leading to what's known as "fall-through" behavior.

End

This is where the process of the switch statement concludes, and the program moves on to execute any remaining code outside of the switch statement.

A flowchart for a switch statement is particularly useful for visual learners, as it clearly illustrates the decision-making process and how the program's flow is directed based on specific conditions. This can be a great tool for debugging or explaining the logic of your C++ code to others.

Working of Switch Statement in C++

The working of a switch statement in C++ is all about making decisions in your code. It's like a multi-road junction where each road leads to a different destination based on the direction you choose. In the case of a switch statement, the direction you choose is determined by the value of a variable.

Here's how it works step by step:

Start with the Expression

When a switch statement is encountered in your code, C++ first looks at the expression inside the switch parentheses. This expression is usually a variable, and its value is what the whole decision-making process is based on.

Check Against Each Case

The value of the expression is then compared with each case value one by one, starting from the top. C++ goes down the list of cases until it finds a match. If the value of the expression matches a case value, C++ starts executing the code block associated with that case.

Execute Code Block

Once a matching case is found, the commands inside that case's code block are run. This block can contain any number of statements, and it executes just like any other part of your program.

Encounter the Break

If there's a break statement at the end of the code block, C++ exits the switch statement entirely and moves on to the next part of your code. If there's no break, C++ might continue checking the cases below, even if they don't match the expression's value, which can lead to unexpected results.

Default Case (Optional)

If none of the case values match the expression's value, and there's a default case provided, C++ will execute the code block under the default case. This is your catch-all option for any values you didn't explicitly handle with a case.

The switch statement is a powerful tool in C++ for handling multiple potential values of a single variable. It keeps your code clean and readable, especially when you have a lot of conditions to check. Understanding how it works helps you make better decisions about when and how to use it in your programming projects.

Important Points About Switch Case Statements

When you're using switch case statements in C++, there are some key points you should always keep in mind. These points will help you avoid common mistakes and make your code more efficient and easier to read.

Initialization Inside Cases

If you need to declare and initialize new variables inside a case, always enclose the case block in curly braces {}. This creates a local scope for the variables, preventing errors related to variable scope and redeclaration.

Avoid Fall-Through Unless Intentional

Fall-through happens when you don't use a break statement at the end of a case block, causing the program to execute the code in the next case as well. This can be useful in some situations but can lead to bugs if not intended. Use break statements wisely to control the flow of execution.

Expression Limitations

The switch expression must be an integer or an enumerated type. This means you can't use strings or floating-point numbers directly. If you need to make decisions based on these types of values, consider using if-else statements or converting your values to an integer or enum.

Default Case Placement

The default case can be placed anywhere within the switch statement, not necessarily at the end. However, placing it at the end is a common practice as it improves readability and logically serves as the "catch-all" option.

Case Value Restrictions

Case values must be constant expressions. This means you can't use variables or runtime expressions for case values. They need to be determined at compile time.

Equality Checks Only

Switch case statements can only check for equality. If you need to evaluate conditions that involve ranges or inequalities, you'll need to use if-else statements instead.

Readability and Maintenance

Switch case statements are great for improving the readability of your code when dealing with multiple specific values for a variable. However, if you find yourself dealing with too many cases or overly complex logic within each case, it might be time to consider breaking your code into smaller functions or using a different approach.

Examples of Switch Statement in C++

Let's look into more examples of using switch statements in C++ to see how versatile and useful they can be in different scenarios. These examples will help solidify your understanding and show you the practical applications of switch statements in your coding projects.

Example 1: Simple Menu System

Imagine you're creating a simple menu system for a console application. You want to display a list of options and perform different actions based on the user's choice.

• C++

C++

#include <iostream>
using namespace std;

int main() {
    int choice;

    cout << "Menu\n";
    cout << "1. Say Hello\n";
    cout << "2. Say Goodbye\n";
    cout << "3. Exit\n";
    cout << "Enter your choice (1-3): ";
    cin >> choice;

    switch (choice) {
        case 1:
            cout << "Hello!\n";
            break;
        case 2:
            cout << "Goodbye!\n";
            break;
        case 3:
            cout << "Exiting...\n";
            break;
        default:
            cout << "Invalid choice. Please enter 1, 2, or 3.\n";
    }

    return 0;
}

You can also try this code with Online C++ Compiler

Run Code

Output

Menu
1. Say Hello
2. Say Goodbye
3. Exit
Enter your choice (1-3): 2
Goodbye!

In this example, we present the user with a simple menu. The switch statement is used to execute different code blocks based on the user's input. It's a straightforward way to handle multiple choices without cluttering your code with if-else statements.

Example 2: Grading System

Now, let's say you're building a simple grading system where you assign a letter grade based on a numerical score. A switch statement can simplify this process.

• C++

C++

#include <iostream>
using namespace std;

int main() {
    int score;
    char grade;

    cout << "Enter your score (0-100): ";
    cin >> score;

    switch (score / 10) {
        case 10:
        case 9:
            grade = 'A';
            break;
        case 8:
            grade = 'B';
            break;
        case 7:
            grade = 'C';
            break;
        case 6:
            grade = 'D';
            break;
        default:
            grade = 'F';
    }

    cout << "Your grade is " << grade << ".\n";

    return 0;
}

You can also try this code with Online C++ Compiler

Run Code

Output

Enter your score (0-100): 4
Your grade is F.

This example demonstrates a clever use of switch statements where we divide the score by 10 to reduce the range of possible cases. The cases for 'A' grade show the "fall-through" feature of switch statements, where multiple cases lead to the same block of code if there's no break statement.

Advantages of Switch Statement in C++

Switch statements in C++ come with several advantages that make them a valuable tool in certain programming scenarios. Understanding these benefits can help you decide when it's best to use a switch statement instead of other conditional statements like if-else.

Readability

Switch statements can make your code more readable and organized, especially when you have a single variable being compared against multiple values. Each case acts like a clear, separate branch of logic, making it easier to understand what your code is doing.

Simplicity

Writing a switch statement is often simpler and cleaner than writing multiple if-else statements, particularly when dealing with many conditions. It helps keep your code concise.

Performance

In some cases, switch statements can be more efficient than if-else statements. This is because some compilers optimize switch statements into jump tables or binary search checks, which can be faster than sequential if-else checks. This isn't always the case, but for a large number of cases with integral or enumerated types, it can provide a performance boost.

Fall-through Logic

The ability to fall through from one case to another can be advantageous in certain situations where multiple cases should execute the same block of code. This feature can reduce code duplication and simplify logic, though it should be used carefully to avoid unintentional fall-through.

Error Checking

Some compilers will warn you if you forget to include a break statement in a case (unless there's an intentional fall-through) or if you have cases that are never reachable. This can help catch errors in your logic.

Flexibility with Constants

Switch statements work with constant expressions, which means you can use them with defined constants or enumerations, making your code more flexible and easier to maintain.

Note -: While switch statements offer these advantages, it's important to remember they're not always the right choice for every situation. They work best when you have a single variable that can take on a range of discrete values that need to be checked against. In scenarios where conditions are more complex or not solely based on equality, an if-else statement might be more appropriate.

Disadvantages of Switch Statement in C++

While switch statements in C++ are useful in many scenarios, they also have some limitations and disadvantages that you should be aware of. Knowing these can help you make better decisions about when to use switch statements and when to opt for alternative control structures like if-else statements.

Limited to Equality Checks

Switch statements can only perform equality checks. This means you can't use them for range checks or more complex conditions that involve logical operators like &&, ||, or !.

Integral or Enumerated Types Only

The expression in a switch statement must evaluate to an integral (such as int or char) or an enumerated type. You cannot use switch statements with floating-point types, strings, or other non-integer types directly.

Risk of Fall-Through Errors

One of the unique features of switch statements is the ability to "fall through" from one case to the next if there's no break statement. While this can be useful in some cases, it can also lead to bugs if you forget to include a break accidentally.

Verbosity for Simple Conditions

If you're only checking a variable against a couple of values, a switch statement might be more verbose than necessary, making an if-else statement a simpler and clearer choice.

Case Value Limitations

Each case in a switch statement requires a unique, constant value. This means you can't use variables or non-constant expressions as case values, which can limit flexibility in some situations.

Default Case Overreliance

While the default case is useful for catching unexpected values, overreliance on it can mask errors or unexpected behavior in your code. It's important to ensure that all expected cases are explicitly handled.

Frequently Asked Questions

Can I use a switch statement with strings in C++?

No, switch statements in C++ do not directly support strings. They work with integral types (like int and char) and enumerated types. To use a switch statement with strings, you would need to convert the strings to a supported type, such as using a hash function to convert strings to integers, though this approach requires careful handling to avoid collisions.

How does a switch statement differ from if-else statements in terms of performance?

Switch statements can offer better performance than if-else chains in some cases, especially with a large number of cases. This is because compilers might optimize switch statements into jump tables or binary search, leading to faster execution. However, the performance gain depends on the specific scenario, the compiler, and the number of cases.

Is it mandatory to use the break statement in each case of a switch statement?

While it's not mandatory, it's highly recommended to use the break statement to prevent fall-through, where the execution continues into the next case. Omitting break can lead to bugs unless you intentionally want to fall through to the next case.

Conclusion

In this article, we explored the switch statement in C++, a versatile tool for managing multiple conditional branches based on the value of a single variable. We covered its syntax, practical examples, essential rules, and the flow of execution to give you a comprehensive understanding of how and when to use switch statements in your code. We also discussed the advantages, like improved readability and potential performance gains, alongside disadvantages, such as limitations to equality checks and support for only integral and enumerated types.

You can refer to our guided paths on the Coding Ninjas. You can check our course to learn more about DSA, DBMS, Competitive Programming, Python, Java, JavaScript, etc. Also, check out some of the Guided Paths on topics such as Data Structure and Algorithms, Competitive Programming, Operating Systems, Computer Networks, DBMS, System Design, etc., as well as some Contests, Test Series, and Interview Experiences curated by top Industry Experts.