We approach this class-averaging program with a technique called top-down, stepwise refinement, which is essential to the development of well-structured programs. We begin with a pseudocode representation of the top—a single statement that conveys the overall purpose of the program:

Determine the class average for the quiz

The top is, in effect, a complete representation of a program. Unfortunately, the top rarely conveys sufficient detail from which to write a C# app. So we now begin the refinement process. We divide the top into a series of smaller tasks and list these in the order in which they’ll be performed. This results in the following first refinement:

Initialize variables
Input, sum and count the quiz grades
Calculate and print the class average

This refinement uses only the sequence structure—the steps listed should execute in order, one after the other.

The preceding Software Engineering Observation is often all you need for the first refinement in the top-down process. To proceed to the next level of refinement—that is, the second refinement—we commit to specific variables. In this example, we need a running total of the numbers, a count of how many numbers have been processed, a variable to receive the value of each grade as it’s entered by the user and a variable to hold the calculated average. The pseudocode statement

Initialize variables

can be refined as follows:

Initialize total to zero
Initialize counter to zero

Only the variables total and counter need to be initialized before they’re used. The variables average and grade (for the calculated average and the user input, respectively) need not be initialized, because their values will be replaced as they’re calculated or input.

The pseudocode statement

Input, sum and count the quiz grades

requires iteration to successively input each grade. We do not know in advance how many grades will be entered, so we’ll use sentinel-controlled iteration. The user enters grades one at a time. After entering the last grade, the user enters the sentinel value. The program tests for the sentinel value after each grade is input and terminates the loop when the user enters the sentinel value. The second refinement of the preceding pseudocode statement is then

Prompt the user to enter the first grade
Input the first grade (possibly the sentinel)
While the user has not yet entered the sentinel
    Add this grade into the running total
    Add one to the grade counter
    Prompt the user to enter the next grade
    Input the next grade (possibly the sentinel)

We simply indent the statements under the While to show that they belong to the While. Again, pseudocode is only an informal program-development aid.

The pseudocode statement

Calculate and print the class average

can be refined as follows:

If the counter is not equal to zero
      Set the average to the total divided by the counter
      Print the average
Else
      Print “No grades were entered”

We’re careful here to test for the possibility of division by zero—a logic error that, if undetected, would cause the program to fail or produce invalid output. The complete second refinement of the pseudocode for the class-average problem is shown in Fig. 5.10.

In Fig. 5.8 and Fig. 5.10, we included blank lines and indentation in the pseudocode to make it more readable. The blank lines separate the algorithms into their phases and set off control statements; the indentation emphasizes the bodies of the control statements.

The pseudocode algorithm in Fig. 5.10 solves the more general class-average problem. This algorithm was developed after two refinements. Sometimes more are needed.

In Fig. 5.11, method Main implements the pseudocode algorithm of Fig. 5.10. Although each grade entered by the user is an integer, the averaging calculation is likely to produce a number with a decimal point—in other words, a real number or floating-point number (e.g., 7.33, 0.0975 or 1000.12345). The type int cannot represent such a number, so this example must use another type to do so. C# provides data types float and double to store floating-point numbers in memory. The primary difference between these types is that double variables can typically store numbers with larger magnitude and finer detail (i.e., more digits to the right of the decimal point—also known as the number’s precision). We say more about floating-point types in Chapter 6.

Recall that integer division produces an integer result. This program introduces a special operator called a cast operator to force the averaging calculation to produce a floating-point numeric result. This program also stacks control statements on top of one another (in sequence)—the while statement (lines 19–27) is followed in sequence by an if…else statement (lines 31–44). Much of the code in this program is identical to that in Fig. 5.9, so we concentrate on the new concepts.

Line 11 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 34 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. 5.9. In counter-controlled iteration, each iteration of the while statement (lines 14–20 of Fig. 5.9) 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 15–16 of Fig. 5.11) 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 (line 19), 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 21–22). Then lines 25–26 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 27, 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 31–44 executes. Line 31 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. 5.11 (lines 20–27). 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’s 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 grade from user
Console.Write("Enter grade or -1 to quit: ");
grade = int.Parse(Console.ReadLine());

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

If at least one grade was entered, line 34 of Fig. 5.11

double average = (double) total / gradeCounter;

calculates the average. Recall from Fig. 5.9 that integer division yields an integer result. Even though variable average is declared as a double, if we had written line 34 as

double average = total / gradeCounter;

it would lose the fractional part of the quotient before the result of the division was used to initialize average.

Line 39

Console.WriteLine($"Class average is {average:F}");

outputs the class average. In this example, we decided that we’d like to display the class average rounded to the nearest hundredth and output the average with exactly two digits to the right of the decimal point. The format specifier F in the interpolation expression

{average:F}

typically formats average’s value with two digits to the right of the decimal point—again, the Windows culture settings on the user’s machine determine the actual format, including the digits to the right of the decimal point, whether commas or periods are used for separating thousands, millions, etc.