Switch Statements

In this lesson, we focus on switch statements. These are another way to write conditional logic. acting as an alternative to the if, else, and if else statements we covered in the previous lesson.

Conditional Logic

Use booleans and if statements to make our functions and programs more dynamic, choosing different execution paths.

This section will guide you through:

• Understanding Switch Statements: Grasp how switch statements offer an alternative to traditional if-else chains, especially when dealing with specific variable values.
• Implementing Cases and Breaks: Learn to use case and break keywords to control the flow of your program.
• Exploring Fallthrough Logic: Discover how fallthrough works in switch statements and how it can be both useful and tricky.
• Utilizing the Default Case: Find out how the default case acts as a catch-all for any unhandled cases.

By the end of this lesson, you'll be equipped to use switch statements effectively in your C++ programs.

An Example Switch Statement

Switch statements are best introduced by an example so below, we have a program that logs out different strings based on the value of an integer Day variable:

1#include <iostream>
2
3using namespace std;
4int Day{3};
5
6int main(){
7  switch (Day) {
8  case 1: // Is Day == 1?
9    cout << "Monday";
10    break;
11  case 2: // Is Day == 2?
12    cout << "Tuesday";
13    break;
14  case 3: // Is Day == 3?
15    cout << "Wednesday";
16    break;
17  }
18}

In this example, we’re switching on the value of Day. Its value is 3, so we trigger the case 3: scenario, logging out Wednesday:

1Wednesday

Fallthrough

Sometimes, we want behaviour to trigger if our variable has one of multiple values, somewhat similar to behavior we can implement using the boolean || operator.

In the following switch statement, we log out "Weekend" if the value of Day is either 6 or 7:

1#include <iostream>
2
3using namespace std;
4int Day{6};
5
6int main(){
7  switch (Day) {
8  case 1:
9    cout << "Monday";
10    break;
11  case 2:
12    cout << "Tuesday";
13    break;
14  case 6:
15  case 7:
16    cout << "Weekend";
17  }
18}

In this program, the value of Day was 6, so we got the expected output:

1Weekend

This is an example of fallthrough, a quirky characteristic of switch statements. In this case, the fallthrough was desired, but it’s often a source of bugs.

Preventing Fallthrough with break

The inclusion of the break keyword in the previous examples is to prevent fallthrough, which is the default behavior of switch statements.

Let's take a look at what happens if we don’t include the break statements:

1#include <iostream>
2
3using namespace std;
4int Day{1};
5
6int main(){
7  switch (Day) {
8  case 1:
9    cout << "Monday";
10  case 2:
11    cout << "Tuesday";
12  case 3:
13    cout << "Wednesday";
14  }
15}

Once a case statement is triggered, every subsequent case statement is also triggered, until we either reach the end of the switch statement or encounter a break instruction.

In this scenario, because the first case was triggered, and we have no break statements, the code in every case was executed. This generated the following output:

1MondayTuesdayWednesday

Fallthrough behavior is rarely useful, but it remains the default implementation of switch statements in C++, and most other programming languages.

So, we should be mindful of it and generally remember that, in most scenarios, we’ll need to add breaks to our switch statements.

Adding a default Case

Switch statements can have a default case, which is activated in all scenarios unless a previously activated case triggered a break:

1#include <iostream>
2
3using namespace std;
4int Day{3};
5
6int main(){
7  switch (Day) {
8  case 1:
9    cout << "Monday";
10    break;
11  case 2:
12    cout << "Tuesday";
13    break;
14  default:
15    cout << "Something else";
16  }
17}

1Something else

1#include <iostream>
2
3using namespace std;
4int Day{1};
5
6int main(){
7  switch (Day) {
8  case 1:
9    cout << "Monday";
10  case 2:
11    cout << "Tuesday";
12    break;
13  default:
14    cout << "Something else";
15  }
16}

Summary

Congratulations on completing this lesson on switch statements! Here's a quick recap of what we've covered:

• Switch Statement Basics: You've learned how switch statements provide a streamlined way to handle multiple conditions based on the value of a variable.
• The case and break Keywords: We explored how to use case and break to control the flow within switch statements.
• Understanding Fallthrough: You now understand how fallthrough works and its potential as both a useful feature and a source of bugs.
• The default Case: We discussed the importance of the default case as a catch-all mechanism.

Up Next: Function Return Types and Values

In our next lesson, we'll return to our exploration of functions. You'll learn about:

• Function Returns: Understanding how functions can return values to their caller.
• Function Returns and Conditional Logic: Understanding how function returns interact with the conditional logic we learned in the previous two lessons
• Exit Codes: Be introduced to the mechanism that allows our main function to communicate its status to the operating system whenever our program ends

Next Lesson

Function return Statements

Allow our functions to communicate with their caller by returning values when they complete

ContinueView Course