Line 10 initializes gradeCounter to 0, because no grades have been entered yet. Remember that this program uses sentinel-controlled iteration to input the grades. The program increments gradeCounter only when the user enters a valid grade. Line 32 declares double variable average, which stores the class average as a floating-point number.

Compare the program logic for sentinel-controlled iteration in this program with that for counter-controlled iteration in Fig. 4.10. In counter-controlled iteration, each iteration of the while statement (lines 12–18 of Fig. 4.10) reads a value from the user, for the specified number of iterations. In sentinel-controlled iteration, the program prompts for and reads the first value (lines 14 and 16 of Fig. 4.12) before reaching the while. This value determines whether the program’s flow of control should enter the body of the while. If the condition of the while is false, the user entered the sentinel value, so the body of the while does not execute (i.e., no grades were entered). If, on the other hand, the condition is true, the body begins execution, and the loop adds the grade value to the total and increments the gradeCounter (lines 20–21). Then lines 24–25 in the loop body input the next value from the user. Next, program control reaches the closing right brace of the loop body at line 26, so execution continues with the test of the while’s condition (line 19). The condition uses the most recent grade entered by the user to determine whether the loop body should execute again.

The value of variable grade is always input from the user immediately before the program tests the while condition. This allows the program to determine whether the value just input is the sentinel value before the program processes that value (i.e., adds it to the total). If the sentinel value is input, the loop terminates, and the program does not add –1 to the total.

After the loop terminates, the if…else statement at lines 30–42 executes. The condition at line 30 determines whether any grades were input. If none were input, the if…else statement’s else part executes and displays the message "No grades were entered".

Notice the while statement’s block in Fig. 4.12 (lines 19–26). Without the braces, the loop would consider its body to be only the first statement, which adds the grade to the total. The last three statements in the block would fall outside the loop body, causing the computer to interpret the code incorrectly as follows:

while (grade != -1)
   total = total + grade; // add grade to total
gradeCounter = gradeCounter + 1; // increment counter

// prompt for input and read next grade from user
cout << "Enter grade or -1 to quit: ";
cin >> grade;

The preceding code would cause an infinite loop in the program if the user did not input the sentinel -1 at line 16 (before the while statement).

To perform a floating-point calculation with integers in this example, you first create temporary floating-point values using the static_cast operator. Line 32 converts a temporary copy of its operand in parentheses (total) to the type in angle brackets (double). The value stored in total is still an integer. Using a cast operator in this manner is called explicit conversion.

After the cast operation, the calculation consists of the temporary double copy of total divided by the integer gradeCounter. For arithmetic, the compiler knows how to evaluate only expressions in which the operand types are identical. To ensure this, the compiler performs an operation called promotion (also called implicit conversion) on selected operands. In an expression containing values of data types int and double, C++ promotes int operands to double values. So in line 32, C++ promotes a temporary copy of gradeCounter’s value to type double, then performs the division. Finally, average is initialized with the floating-point result. Section 6.5 discusses the allowed fundamental-type promotions.

Cast operators are available for use with every fundamental type and with class types as well. The operator is formed by following keyword static_cast with a type name in angle brackets (< and >). It’s a unary operator—that is, it has only one operand. C++ also supports unary versions of the plus (+) and minus (-) operators, so that you can write such expressions as -7 or +5. Cast operators have the second highest precedence (Appendix A).

The call to setprecision (with the argument 2) in line 37

cout << setprecision(2) << fixed;

indicates that floating-point values should be output with two digits of precision to the right of the decimal point (e.g., 92.37). setprecision is a parameterized stream manipulator, because it requires an argument to perform its task. Programs that use these calls must include the header <iomanip> (line 4). The manipulator endl (from the header <iostream>) is a nonparameterized stream manipulator, because it does not require an argument. By default, floating-point values are output with six digits of precision.

The stream manipulator fixed (line 37) indicates that floating-point values should be output in fixed-point format, as opposed to scientific notation. Scientific notation is a way of displaying a number as a floating-point number between the values of 1.0 and 10.0, multiplied by a power of 10. For instance, the value 3,100.0 would be displayed in scientific notation as ${3.1\times 10}^3$. Scientific notation is useful when displaying very large or very small values. Formatting using scientific notation is discussed further in Chapter 13.

Fixed-point formatting forces a floating-point number to display a specific number of digits. Fixed-point formatting also forces the decimal point and trailing zeros to print, even if the value is a whole-number amount, such as 88.00. Without the fixed-point formatting option, 88.00 prints as 88 without the trailing zeros and decimal point.

When the stream manipulators fixed and setprecision are used, the printed value is rounded to the number of decimal positions indicated by setprecision’s argument (2 in this example), although the value in memory remains unaltered. For example, the values 87.946 and 67.543 are output as 87.95 and 67.54, respectively. It’s also possible to force a decimal point to appear by using stream manipulator showpoint. If showpoint is specified without fixed, then trailing zeros will not print. Like endl, the nonparameterized stream manipulators fixed and showpoint require the header <iostream>.

Together, lines 37 and 38 of Fig. 4.12 output the class average rounded to the nearest hundredth and with exactly two digits to the right of the decimal point. The three grades entered during the execution of the program in Fig. 4.12 total 257, which yields the average 85.666… and prints with rounding as 85.67.