Switch Statements

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

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.

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.

Because the fallthrough behavior is rarely useful and a frequent source of bugs, most modern compilers will issue a warning when they encounter it.

Compilers use warnings to notify us when they detect something in our code that is technically valid, but considered unusual and potentially problematic.

IDEs will typically present compiler warnings somewhere on their UI after our program compiles. In Visual Studio, we can see warnings by expanding the View menu from the top menu bar, and selecting Error List

In scenarios where we want to use fallthrough, we can add a [[fallthrough]] statement:

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

This does not change the behaviour of our program, but it clarifies to the compiler (and anyone reading our code) that we're intentionally using fallthrough in that location. This will also eliminate the compiler warning.

Syntax that is wrapped in [[ and ]], such as [[fallthrough]], are called attributes. We cover attributes in a dedicated lesson later in the course.

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}

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.