C++ Control Statements, Part 2

This chapter is from the book

C++20 for Programmers: An Objects-Natural Approach, 3rd Edition

Learn More Buy

This chapter is from the book

This chapter is from the book 

C++20 for Programmers: An Objects-Natural Approach, 3rd Edition

Learn More Buy

4.8 switch Multiple-Selection Statement

C++ provides the switch multiple-selection statement to choose among many different actions based on the possible values of a variable or expression. Each action is associated with the value of an integral constant expression—any combination of character and integer constants that evaluates to a constant integer value.

Using a switch Statement to Count A, B, C, D and F Grades

Figure 4.6 calculates the class average of a set of numeric grades entered by the user. The switch statement determines each grade’s letter equivalent (A, B, C, D or F) and increments the appropriate grade counter. The program also displays a summary of the number of students who received each grade.

 1   // fig04_06.cpp
 2   // Using a switch statement to count letter grades.
 3   #include <iostream>
 4   #include <iomanip>
 5   using namespace std;
 6
 7   int main() {
 8      int total{0}; // sum of grades
 9      int gradeCounter{0}; // number of grades entered
10      int aCount{0}; // count of A grades
11      int bCount{0}; // count of B grades
12      int cCount{0}; // count of C grades
13      int dCount{0}; // count of D grades
14      int fCount{0}; // count of F grades
15
16      cout << "Enter the integer grades in the range 0-100.\n"
17         << "Type the end-of-file indicator to terminate input:\n"
18         << " On UNIX/Linux/macOS type <Ctrl> d then press Enter\n"
19         << " On Windows type <Ctrl> z then press Enter\n";
20
21      int grade;
22
23      // loop until user enters the end-of-file indicator
24      while (cin >> grade) {
25         total += grade; // add grade to total
26         ++gradeCounter; // increment number of grades
27
28         // increment appropriate letter-grade counter
29         switch (grade / 10) {
30            case 9: // grade was between 90
31            case 10: // and 100, inclusive
32               ++aCount;
33               break; // exits switch
34
35            case 8: // grade was between 80 and 89
36               ++bCount;
37               break; // exits switch
38
39            case 7: // grade was between 70 and 79
40               ++cCount;
41               break; // exits switch
42
43            case 6: // grade was between 60 and 69
44               ++dCount;
45               break; // exits switch
46
47            default: // grade was less than 60
48               ++fCount;
49               break; // optional; exits switch anyway
50         } // end switch
51      } // end while
52
53      // set floating-point number format
54      cout << fixed << setprecision(2);
55
56      // display grade report
57      cout << "\nGrade Report:\n";
58
59      // if user entered at least one grade...
60      if (gradeCounter != 0) {
61         // calculate average of all grades entered
62         double average{static_cast<double>(total) / gradeCounter};
63
64         // output summary of results
65         cout << "Total of the " << gradeCounter << " grades entered is "
66            << total << "\nClass average is " << average
67            << "\nNumber of students who received each grade:"
68            << "\nA: " << aCount << "\nB: " << bCount << "\nC: " << cCount
69            << "\nD: " << dCount << "\nF: " << fCount << "\n";
70      }
71      else { // no grades were entered, so output appropriate message
72         cout << "No grades were entered" << "\n";
73      }
74   }

Enter the integer grades in the range 0-100.
Type the end-of-file indicator to terminate input:
   On UNIX/Linux/macOS type <Ctrl> d then press Enter
   On Windows type <Ctrl> z then press Enter
99
92
45
57
63
71
76
85
90
100
^Z

Grade Report:
Total of the 10 grades entered is 778
Class average is 77.80
Number of students who received each grade:
A: 4
B: 1
C: 2
D: 1
F: 2

Figure 4.6 declares local variables total (line 8) and gradeCounter (line 9) to keep track of the sum of the grades entered by the user and the number of grades entered. Lines 10–14 declare and initialize to 0 counter variables for each grade category. Lines 24–51 input an arbitrary number of integer grades using sentinel-controlled iteration, update variables total and gradeCounter, and increment an appropriate letter-grade counter for each grade entered. Lines 54–73 output a report containing the total of all grades entered, the average grade and the number of students who received each letter grade.

Reading Grades from the User

Lines 16–19 prompt the user to enter integer grades or type the end-of-file indicator to terminate the input. The end-of-file indicator is a system-dependent keystroke combination used to indicate that there’s no more data to input. In Chapter 8, you’ll see how the end-of-file indicator is used when a program reads its input from a file.

The keystroke combinations for entering end-of-file are system dependent. On UNIX/Linux/macOS systems, type the sequence

<Ctrl> d

on a line by itself. This notation means to press both the Ctrl key and the d key simultaneously. On Windows systems, type

<Ctrl> z

On some systems, you must also press Enter. Also, Windows typically displays ^Z on the screen when you type the end-of-file indicator, as shown in the output of Fig. 4.6.

The while statement (lines 24–51) obtains the user input. Line 24

while (cin >> grade) {

performs the input in the while statement’s condition. In this case, the loop-continuation condition evaluates to true if cin successfully reads an int value. If the user enters the end-of-file indicator, the condition evaluates to false.

If the condition is true, line 25 adds grade to total, and line 26 increments grade-Counter. These are used to compute the average. Next, lines 29–50 use a switch statement to increment the appropriate letter-grade counter based on the numeric grade entered.

Processing the Grades

The switch statement (lines 29–50) determines which counter to increment. We assume that the user enters a valid grade in the range 0–100. A grade in the range 90–100 represents A, 80–89 represents B, 70–79 represents C, 60–69 represents D and 0–59 represents F. The switch statement’s block contains a sequence of case labels and an optional default case, which can appear anywhere in the switch, but normally appears last. These are used in this example to determine which counter to increment based on the grade.

When the flow of control reaches the switch, the program evaluates the controlling expression in the parentheses (grade / 10) following keyword switch. The program compares this expression’s value with each case label. The expression must have a signed or unsigned integral type—bool, char, char8_t, char16_t, char32_t, wchar_t, int, long or long long.

The controlling expression in line 29 performs integer division, which truncates the fractional part of the result. When we divide a value from 0 to 100 by 10, the result is always a value from 0 to 10. We use several of these values in our case labels. If the user enters the integer 85, the controlling expression evaluates to 8. The switch compares 8 with each case label. If a match occurs (case 8: at line 35), that case’s statements execute. For 8, line 36 increments bCount, because a grade in the 80s is a B. The break statement (line 37) exits the switch. In this program, we reach the end of the while loop, so control returns to the loop-continuation condition in line 24 to determine whether the loop should continue executing.

The cases in our switch explicitly test for the values 10, 9, 8, 7 and 6. Note the cases at lines 30–31 that test for the values 9 and 10 (both of which represent the grade A). Listing cases consecutively in this manner with no statements between them enables the cases to perform the same set of statements—when the controlling expression evaluates to 9 or 10, the statements in lines 32–33 execute. The switch statement does not provide a mechanism for testing ranges of values, so every value you need to test must be listed in a separate case label. Each case can have multiple statements. The switch statement differs from other control statements in that it does not require braces around multiple statements in a case, unless you need to declare a variable in a case.

case without a break Statement—C++17 [[fallthrough]] Attribute

Without break statements, each time a match occurs in the switch, the statements for that case and subsequent cases execute until a break statement or the end of the switch is reached. This is referred to as “falling through” to the statements in subsequent cases.⁴

Err 17 Forgetting a break statement when one is needed is a logic error. To call your attention to this possible problem, many compilers issue a warning when a case label is followed by one or more statements and does not contain a break statement. For such instances in which “falling through” is the desired behavior, C++17 introduced the [[fallthrough]] attribute. You can tell the compiler that “falling through” to the next case is the correct behavior by placing the statement

[[fallthrough]];

where the break statement would normally appear.

The default Case

If no match occurs between the controlling expression’s value and any of the case labels, the default case (lines 47–49) executes. We use the default case in this example to process all controlling-expression values that are less than 6—that is, all failing grades. If no match occurs and the switch does not contain a default case, program control simply continues with the first statement after the switch. In a switch, it’s good practice to test for all possible values of the controlling expression.

Displaying the Grade Report

Lines 54–73 output a report based on the grades entered. Line 60 determines whether the user entered at least one grade—this helps us avoid dividing by zero, which for integer division causes the program to fail and for floating-point division produces the value nan—for “not a number.” If so, line 62 calculates the average of the grades. Lines 65–69 then output the total of all the grades, the class average and the number of students who received each letter grade. If no grades were entered, line 72 outputs an appropriate message. The output in Fig. 4.6 shows a sample grade report based on 10 grades.

switch Statement UML Activity Diagram

The following is the UML activity diagram for the general switch statement:

Click to view larger image

Most switch statements use a break in each case to terminate the switch after the case is processed. The diagram emphasizes this by including break statements and showing that the break at the end of a case causes control to exit the switch statement immediately.

The break statement is not required for the switch’s last case (or the optional default case, when it appears last), because execution continues with the next statement after the switch. Provide a default case in every switch statement to focus you on processing exceptional conditions.

Notes on cases

Each case in a switch statement must contain a constant integral expression—that is, any expression that evaluates to a constant integer value. You also can use enum constants (introduced in Section 5.9) and character literals—specific characters in single quotes, such as 'A', '7' or '$', which represent the integer values of characters. (Appendix B shows the integer values of the characters in the ASCII character set, which is a subset of the Unicode character set.)

In Chapter 10, OOP: Inheritance and Runtime Polymorphism, we present a more elegant way to implement switch logic. We use a technique called polymorphism to create programs that are often clearer, easier to maintain and easier to extend than programs using switch logic.