The sequence structure is built into C#. Unless directed otherwise, the computer executes C# statements one after the other in the order in which they’re written—that is, in sequence. The UML activity diagram in Fig. 5.1 illustrates a typical sequence structure in which two calculations are performed in order. C# lets you have as many actions as you want in a sequence structure.

Figure 5.1. Sequence structure activity diagram.

An activity diagram models the workflow (also called the activity) of a portion of a software system. Such workflows may include a portion of an algorithm, such as the sequence structure in Fig. 5.1. Activity diagrams are composed of special-purpose symbols, such as action-state symbols (rectangles with their left and right sides replaced with arcs curving outward), diamonds and small circles. These symbols are connected by transition arrows, which represent the flow of the activity—that is, the order in which the actions should occur.

Like pseudocode, activity diagrams help you develop and represent algorithms, although many programmers prefer pseudocode. Activity diagrams clearly show how control structures operate.

Consider the activity diagram for the sequence structure in Fig. 5.1. It contains two action states that represent actions to perform. Each action state contains an action expression—for example, “add grade to total” or “add 1 to counter”—that specifies an action to perform. Other actions might include calculations or input/output operations. The arrows in the activity diagram represent transitions, which indicate the order in which the actions occur. The portion of the application that implements the activities illustrated by the diagram in Fig. 5.1 first adds grade to total, then adds 1 to counter.

The solid circle located at the top of the activity diagram represents the activity’s initial state—the beginning of the workflow before the application performs the modeled actions. The solid circle surrounded by a hollow circle that appears at the bottom of the diagram represents the final state—the end of the workflow after the application performs its actions.

Figure 5.1 also includes rectangles with the upper-right corners folded over. These are UML notes (like comments in C#) that describe the purpose of symbols in the diagram. Figure 5.1 uses UML notes to show the C# code associated with each action state in the activity diagram. A dotted line connects each note with the element that the note describes. Activity diagrams normally do not show the C# code that implements the activity. We use notes for this purpose here to illustrate how the diagram relates to C# code.

C# has three types of selection structures, which from this point forward we shall refer to as selection statements. The if statement either performs (selects) an action if a condition is true or skips the action if the condition is false. The if...else statement performs an action if a condition is true or performs a different action if the condition is false. The switch statement (Chapter 6) performs one of many different actions, depending on the value of an expression.

The if statement is called a single-selection statement because it selects or ignores a single action (or, as we’ll soon see, a single group of actions). The if...else statement is called a double-selection statement because it selects between two different actions (or groups of actions). The switch statement is called a multiple-selection statement because it selects among many different actions (or groups of actions).

C# provides four repetition structures, which from this point forward we shall refer to as repetition statements (also called iteration statements or loops). Repetition statements enable applications to perform statements repeatedly, depending on the value of a loop-continuation condition. The repetition statements are the while, do...while, for and foreach statements. (Chapter 6 presents the do...while and for statements. Chapter 8 discusses the foreach statement.) The while, for and foreach statements perform the action (or group of actions) in their bodies zero or more times—if the loop-continuation condition is initially false, the action (or group of actions) will not execute. The do...while statement performs the action (or group of actions) in its body one or more times. The words if, else, switch, while, do, for and foreach are C# keywords.

C# has only three kinds of structured control statements: the sequence statement, selection statement (three types) and repetition statement (four types). We combine as many of each type of statement as necessary to make the program flow and work as required. As with the sequence statement in Fig. 5.1, we can model each control statement as an activity diagram. Each diagram contains one initial state and one final state that represent a control statement’s entry point and exit point, respectively. Single-entry/single-exit control statements make it easy to build applications—the control statements are “attached” to one another by connecting the exit point of one to the entry point of the next. This procedure is similar to the way in which a child stacks building blocks, so we call it control-statement stacking. You’ll learn that there’s only one other way in which control statements may be connected: control-statement nesting, in which a control statement appears inside another control statement. Thus, algorithms in C# applications are constructed from only three kinds of structured control statements, combined in only two ways. This is the essence of simplicity.

C# provides the conditional operator (?:), which can be used in place of an if...else statement. This is C#’s only ternary operator—this means that it takes three operands. Together, the operands and the ?: symbols form a conditional expression. The first operand (to the left of the ?) is a boolean expression (i.e., an expression that evaluates to a bool-type value—true or false), the second operand (between the ? and :) is the value of the conditional expression if the boolean expression is true and the third operand (to the right of the :) is the value of the conditional expression if the boolean expression is false. For example, the statement

Console.WriteLine( grade >= 60 ? "Passed" : "Failed" );

displays the value of WriteLine’s conditional-expression argument. The conditional expression in the preceding statement evaluates to the string "Passed" if the boolean expression grade >= 60 is true and evaluates to the string "Failed" if the boolean expression is false. Thus, this statement with the conditional operator performs essentially the same function as the if...else statement shown earlier in this section, in which the boolean expression grade >= 60 was used as the if...else statement’s condition. Actually, every control statement’s condition must evaluate to the bool-type value true or false. You’ll see that conditional expressions can be used in some situations where if...else statements cannot.

Good Programming Practice 5.3

When a conditional expression is inside a larger expression, it’s good practice to parenthesize the conditional expression for clarity. Adding parentheses may also prevent operator-precedence problems that could cause syntax errors.

An application can test multiple cases by placing if...else statements inside other if...else statements to create nested if...else statements. For example, the following pseudocode represents a nested if...else statement that displays A for exam grades greater than or equal to 90, B for grades in the range 80 to 89, C for grades in the range 70 to 79, D for grades in the range 60 to 69 and F for all other grades:

This pseudocode may be written in C# as

if ( grade >= 90 )
   Console.WriteLine( "A" );
else
   if ( grade >= 80 )
      Console.WriteLine( "B" );
   else
      if ( grade >= 70 )
         Console.WriteLine( "C" );
      else
         if ( grade >= 60 )
            Console.WriteLine( "D" );
         else
            Console.WriteLine( "F" );

If grade is greater than or equal to 90, the first four conditions will be true, but only the statement in the if-part of the first if...else statement will execute. After that statement executes, the else-part of the “outermost” if...else statement is skipped. Most C# programmers prefer to write the preceding if...else statement as

if ( grade >= 90 )
   Console.WriteLine( "A" );
else if ( grade >= 80 )
   Console.WriteLine( "B" );
else if ( grade >= 70 )
   Console.WriteLine( "C" );
else if ( grade >= 60 )
   Console.WriteLine( "D" );
else
   Console.WriteLine( "F" );

The two forms are identical except for the spacing and indentation, which the compiler ignores. The latter form is popular because it avoids deep indentation of the code to the right—such indentation often leaves little room on a line of code, forcing lines to be split and decreasing the readability of your code.

The C# compiler always associates an else with the immediately preceding if unless told to do otherwise by the placement of braces ({ and }). This behavior can lead to what is referred to as the dangling-else problem. For example,

if ( x > 5 )
   if ( y > 5 )
      Console.WriteLine( "x and y are > 5" );
   else
      Console.WriteLine( "x is <= 5" );

appears to indicate that if x is greater than 5, the nested if statement determines whether y is also greater than 5. If so, the string "x and y are > 5" is output. Otherwise, it appears that if x is not greater than 5, the else part of the if...else outputs the string "x is <= 5".

Beware! This nested if...else statement does not execute as it appears. The compiler actually interprets the statement as

if ( x > 5 )
   if ( y > 5 )
      Console.WriteLine( "x and y are > 5" );
   else
      Console.WriteLine( "x is <= 5" );

in which the body of the first if is a nested if...else. The outer if statement tests whether x is greater than 5. If so, execution continues by testing whether y is also greater than 5. If the second condition is true, the proper string—"x and y are > 5"—is displayed. However, if the second condition is false, the string "x is <= 5" is displayed, even though we know that x is greater than 5.

To force the nested if...else statement to execute as it was originally intended, we must write it as follows:

if ( x > 5 )
{
   if ( y > 5 )
      Console.WriteLine( "x and y are > 5" );
}
else
   Console.WriteLine( "x is <= 5" );

The braces ({}) indicate to the compiler that the second if statement is in the body of the first if and that the else is associated with the first if. Exercises 5.27–5.28 investigate the dangling-else problem further.

The if statement expects only one statement in its body. To include several statements in the body of an if (or the body of an else for an if...else statement), enclose the statements in braces ({ and }). A set of statements contained within a pair of braces is called a block. A block can be placed anywhere in an application that a single statement can be placed.

The following example includes a block in the else-part of an if...else statement:

if ( grade >= 60 )
   Console.WriteLine( "Passed" );
else
{
   Console.WriteLine( "Failed" );
   Console.WriteLine( "You must take this course again." );
}

In this case, if grade is less than 60, the application executes both statements in the body of the else and displays

Failed.
You must take this course again.

Note the braces surrounding the two statements in the else clause. These braces are important. Without the braces, the statement

Console.WriteLine( "You must take this course again." );

would be outside the body of the else-part of the if...else statement and would execute regardless of whether the grade was less than 60.

Syntax errors are caught by the compiler. A logic error (e.g., when both braces in a block are left out of the application) has its effect at execution time. A fatal logic error causes an application to fail and terminate prematurely. A nonfatal logic error allows an application to continue executing, but causes it to produce incorrect results.

Good Programming Practice 5.4

Always using braces in an if...else (or other) statement helps prevent their accidental omission, especially when adding statements to the if-part or the else-part at a later time. To avoid omitting one or both of the braces, some programmers type the beginning and ending braces of blocks before typing the individual statements within them.

Just as a block can be placed anywhere a single statement can be placed, it’s also possible to have an empty statement. Recall from Section 3.9 that the empty statement is represented by placing a semicolon (;) where a statement would normally be.

Common Programming Error 5.1

Placing a semicolon after the condition in an if or if...else statement leads to a logic error in single-selection if statements and a syntax error in double-selection if...else statements (when the if-part contains an actual body statement).

Let’s use pseudocode to list the actions to execute and specify the order in which they should execute. We use counter-controlled repetition to input the grades one at a time. This technique uses a variable called a counter (or control variable) to control the number of times a set of statements will execute. Counter-controlled repetition is often called definite repetition, because the number of repetitions is known by the application before the loop begins executing. In this example, repetition terminates when the counter exceeds 10. This section presents a fully developed pseudocode algorithm (Fig. 5.5) and a version of class GradeBook (Fig. 5.6) that implements the algorithm in a C# method. The section then presents an application (Fig. 5.7) that demonstrates the algorithm in action. In Section 5.9, we demonstrate how to use pseudocode to develop such an algorithm from scratch.

 1   // Fig. 5.6: GradeBook.cs
 2   // GradeBook class that solves class-average problem using
 3   // counter-controlled repetition.
 4   using System;
 5
 6   public class GradeBook
 7   {
 8      // auto-implemented property CourseName
 9      public string CourseName { get; set; }
10
11      // constructor initializes CourseName property
12      public GradeBook( string name )
13      {
14         CourseName = name; // set CourseName to name
15      } // end constructor
16
17      // display a welcome message to the GradeBook user
18      public void DisplayMessage()
19      {
20         // property CourseName gets the name of the course
21         Console.WriteLine( "Welcome to the grade book for
{0}!
",
22            CourseName );
23      } // end method DisplayMessage
24
25      // determine class average based on 10 grades entered by user
26      public void DetermineClassAverage()
27      {
28         int total; // sum of the grades entered by user
29         int gradeCounter; // number of the grade to be entered next
30         int grade; // grade value entered by the user
31         int average; // average of the grades
32
33         // initialization phase
34         total = 0; // initialize the total
35         gradeCounter = 1; // initialize the loop counter
36
37         // processing phase
38         while ( gradeCounter <= 10 ) // loop 10 times
39         {
40            Console.Write( "Enter grade: " ); // prompt the user
41            grade = Convert.ToInt32( Console.ReadLine() ); // read grade
42            total = total + grade; // add the grade to total
43            gradeCounter = gradeCounter + 1; // increment the counter by 1
44         } // end while
45
46         // termination phase
47         average = total / 10; // integer division yields integer result
48
49         // display total and average of grades
50         Console.WriteLine( "
Total of all 10 grades is {0}", total );
51         Console.WriteLine( "Class average is {0}", average );
52      } // end method DetermineClassAverage
53   } // end class GradeBook

 1   // Fig. 5.7: GradeBookTest.cs
 2   // Create GradeBook object and invoke its DetermineClassAverage method.
 3   public class GradeBookTest
 4   {
 5      public static void Main( string[] args )
 6     {
 7         // create GradeBook object myGradeBook and
 8         // pass course name to constructor
 9         GradeBook myGradeBook = new GradeBook(
10            "CS101 Introduction to C# Programming" );
11
12         myGradeBook.DisplayMessage(); // display welcome message
13         myGradeBook.DetermineClassAverage(); // find average of 10 grades
14      } // end Main
15   } // end class GradeBookTest

Welcome to the grade book for
CS101 Introduction to C# Programming!
Enter grade: 88
Enter grade: 79
Enter grade: 95
Enter grade: 100
Enter grade: 48
Enter grade: 88
Enter grade: 92
Enter grade: 83
Enter grade: 90
Enter grade: 85

Total of all 10 grades is 848
Class average is 84

Software Engineering Observation 5.1

Experience has shown that the most difficult part of solving a problem on a computer is developing the algorithm for the solution. Once a correct algorithm has been specified, the process of producing a working C# application from it is normally straightforward.

Note the references in the algorithm of Fig. 5.5 to a total and a counter. A total is a variable used to accumulate the sum of several values. A counter is a variable used to count—in this case, the grade counter indicates which of the 10 grades is about to be entered by the user. Variables used to store totals are normally initialized to zero before being used in an application.

Class GradeBook (Fig. 5.6) contains a constructor (lines 12–15) that assigns a value to the instance variable created by auto-implemented property CourseName in line 9. Lines 18–23 declare method DisplayMessage. Lines 26–52 declare method DetermineClassAverage, which implements the class-averaging algorithm described by the pseudocode in Fig. 5.5.

Lines 28–31 declare local variables total, gradeCounter, grade and average to be of type int. In this example, variable total accumulates the sum of the grades entered and gradeCounter counts the number of grades entered. Variable grade stores the most recent grade value entered (line 41). Variable average stores the average grade.

The declarations (in lines 28–31) appear in method DetermineClassAverage’s body. Variables declared in a method body are local variables and can be used only from the line of their declaration to the closing right brace of the block in which they’re declared. A local variable’s declaration must appear before the variable is used in that method. A local variable cannot be accessed outside the method in which it’s declared.

In the versions of class GradeBook in this chapter, we simply read and process a set of grades. The averaging calculation is performed in method DetermineClassAverage using local variables—we do not preserve any information about student grades in instance variables of the class. In later versions of the class (in Chapter 8), we store the grades using an instance variable that refers to a data structure known as an array. This allows a GradeBook object to perform various calculations on the same set of grades without requiring the user to enter the grades multiple times.

Good Programming Practice 5.5

Separate declarations from other statements in methods with a blank line for readability.

We say that a variable is definitely assigned when it’s guaranteed to be assigned a value before it’s used. Notice that each local variable declared in lines 28–31 is definitely assigned before it’s used in calculations. The assignments (in lines 34–35) initialize total to 0 and gradeCounter to 1. Variables grade and average (for the user input and calculated average, respectively) need not be initialized here—their values are assigned as they’re input or calculated later in the method.

Common Programming Error 5.3

Using the value of a local variable before it’s definitely assigned results in a compilation error. All local variables must be definitely assigned before their values are used in expressions.

Error-Prevention Tip 5.1

Initialize each counter and total, either in its declaration or in an assignment statement. Totals are normally initialized to 0. Counters are normally initialized to 0 or 1, depending on how they’re used (we’ll show examples of each).

Line 38 indicates that the while statement should continue looping (also called iterating) as long as the value of gradeCounter is less than or equal to 10. While this condition remains true, the while statement repeatedly executes the statements between the braces that delimit its body (lines 39–44).

Line 40 displays the prompt "Enter grade:" in the console window. Line 41 reads the grade entered by the user and assigns it to variable grade. Then line 42 adds the new grade entered by the user to the total and assigns the result to total, which replaces its previous value.

Line 43 adds 1 to gradeCounter to indicate that the application has processed a grade and is ready to input the next grade from the user. Incrementing gradeCounter eventually causes gradeCounter to exceed 10. At that point the while loop terminates, because its condition (line 38) becomes false.

When the loop terminates, line 47 performs the averaging calculation and assigns its result to the variable average. Line 50 uses Console’s WriteLine method to display the text "Total of all 10 grades is" followed by variable total’s value. Line 51 then displays the text "Class average is" followed by variable average’s value. Method DetermineClassAverage returns control to the calling method (i.e., Main in GradeBookTest of Fig. 5.7) after reaching line 52.

Class GradeBookTest (Fig. 5.7) creates an object of class GradeBook (Fig. 5.6) and demonstrates its capabilities. Lines 9–10 of Fig. 5.7 create a new GradeBook object and assign it to variable myGradeBook. The string in line 10 is passed to the GradeBook constructor (lines 12–15 of Fig. 5.6). Line 12 calls myGradeBook’s DisplayMessage method to display a welcome message to the user. Line 13 then calls myGradeBook’s DetermineClassAverage method to allow the user to enter 10 grades, for which the method then calculates and displays the average—the method performs the algorithm shown in Fig. 5.5.

The averaging calculation performed by method DetermineClassAverage in response to the method call at line 13 in Fig. 5.7 produces an integer result. The application’s output indicates that the sum of the grade values in the sample execution is 848, which, when divided by 10, should yield the floating-point number 84.8. However, the result of the calculation total / 10 (line 47 of Fig. 5.6) is the integer 84, because total and 10 are both integers. Dividing two integers results in integer division—any fractional part of the calculation is lost (i.e., truncated, not rounded). We’ll see how to obtain a floating-point result from the averaging calculation in the next section.

Common Programming Error 5.4

Assuming that integer division rounds (rather than truncates) can lead to incorrect results. For example, 7 ÷ 4, which yields 1.75 in conventional arithmetic, truncates to 1 in integer arithmetic, rather than rounding to 2.

We approach the class-average application with a technique called top-down, stepwise refinement, which is essential to the development of well-structured applications. We begin with a pseudocode representation of the top—a single statement that conveys the overall function of the application:

The top is, in effect, a complete representation of an application. Unfortunately, the top rarely conveys sufficient detail from which to write a C# application. 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:

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

Software Engineering Observation 5.2

Each refinement, as well as the top itself, is a complete specification of the algorithm—only the level of detail varies.

Software Engineering Observation 5.3

Many applications can be divided logically into three phases: an initialization phase that initializes the variables; a processing phase that inputs data values and adjusts application variables (e.g., counters and totals) accordingly; and a termination phase that calculates and outputs the final results.

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, the second refinement, we specify individual 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 input by the user and a variable to hold the calculated average. The pseudocode statement

can be refined as follows:

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

requires a repetition statement that successively inputs each grade. We do not know in advance how many grades are to be processed, so we’ll use sentinel-controlled repetition. The user enters grades one at a time. After entering the last grade, the user enters the sentinel value. The application 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

In pseudocode, we do not use braces around the statements that form the body of the while structure. We simply indent the statements under the while to show that they belong to the while. Again, pseudocode is only an informal application-development aid.

The pseudocode statement

can be refined as follows:

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

Error-Prevention Tip 5.2

When performing division by an expression whose value could be zero, explicitly test for this possibility and handle it appropriately in your application (e.g., by displaying an error message) rather than allowing the error to occur.

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

The pseudocode algorithm in Fig. 5.8 solves the more general class-averaging problem. This algorithm was developed after only two refinements. Sometimes more refinements are necessary.

Software Engineering Observation 5.4

Terminate the top-down, stepwise refinement process when you’ve specified the pseudocode algorithm in sufficient detail for you to convert the pseudocode to C#. Normally, implementing the C# application is then straightforward.

Software Engineering Observation 5.5

Some experienced programmers write applications without ever using application-development tools like pseudocode. They feel that their ultimate goal is to solve the problem on a computer and that writing pseudocode merely delays the production of final outputs. Although this method may work for simple and familiar problems, it can lead to serious errors and delays in large, complex projects.

Figure 5.9 shows the C# class GradeBook containing method DetermineClassAverage that implements the pseudocode algorithm of Fig. 5.8. Although each grade 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. The type int cannot represent such a number, so this class uses type double to do so.

 1   // Fig. 5.9: GradeBook.cs
 2   // GradeBook class that solves class-average problem using
 3   // sentinel-controlled repetition.
 4   using System;
 5
 6   public class GradeBook
 7   {
 8      // auto-implemented property CourseName
 9      public string CourseName { get; set; }
10
11      // constructor initializes the CourseName property
12      public GradeBook( string name )
13      {
14         CourseName = name; // set CourseName to name
15      } // end constructor
16
17      // display a welcome message to the GradeBook user
18      public void DisplayMessage()
19      {
20         Console.WriteLine( "Welcome to the grade book for
{0}!
",
21            CourseName );
22      } // end method DisplayMessage
23
24      // determine the average of an arbitrary number of grades
25      public void DetermineClassAverage()
26      {
27         int total; // sum of grades
28         int gradeCounter; // number of grades entered
29         int grade; // grade value
30         double average; // number with decimal point for average
31
32         // initialization phase
33         total = 0; // initialize total
34         gradeCounter = 0; // initialize loop counter
35
36         // processing phase
37         // prompt for and read a grade from the user   
38         Console.Write( "Enter grade or -1 to quit: " );
39         grade = Convert.ToInt32( Console.ReadLine() ); 
40
41         // loop until sentinel value is read from the user
42         while ( grade != -1 )
43         {
44            total = total + grade; // add grade to total
45            gradeCounter = gradeCounter + 1; // increment counter
46
47            // prompt for and read the next grade from the user
48            Console.Write( "Enter grade or -1 to quit: " );    
49            grade = Convert.ToInt32( Console.ReadLine() );     
50         } // end while
51
52         // termination phase
53         // if the user entered at least one grade...
54         if ( gradeCounter != 0 )
55         {
56            // calculate the average of all the grades entered
57            average = ( double ) total / gradeCounter;        
58
59            // display the total and average (with two digits of precision)
60            Console.WriteLine( "
Total of the {0} grades entered is {1}",
61               gradeCounter, total );
62            Console.WriteLine( "Class average is {0:F}", average );
63         } // end if
64         else // no grades were entered, so output error message
65            Console.WriteLine( "No grades were entered" );
66      } // end method DetermineClassAverage
67   } // end class GradeBook

In this example, we see that control statements may be stacked on top of one another (in sequence) just as a child stacks building blocks. The while statement (lines 42–50) is followed in sequence by an if...else statement (lines 54–65). Much of the code in this application is identical to the code in Fig. 5.6, so we concentrate on the new features and issues.

Line 30 declares double variable average. This variable allows us to store the calculated class average as a floating-point number. Line 34 initializes gradeCounter to 0, because no grades have been entered yet. Remember that this application uses sentinel-controlled repetition to input the grades from the user. To keep an accurate record of the number of grades entered, the application increments gradeCounter only when the user inputs a valid grade value.

Compare the program logic for sentinel-controlled repetition in this application with that for counter-controlled repetition in Fig. 5.6. In counter-controlled repetition, each repetition of the while statement (e.g., lines 38–44 of Fig. 5.6) reads a value from the user, for the specified number of repetitions. In sentinel-controlled repetition, the application reads the first value (lines 38–39 of Fig. 5.9) before reaching the while. This value determines whether the application’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 (because 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 (line 44) and adds 1 to gradeCounter (line 45). Then lines 48–49 in the loop’s body input the next value from the user. Next, program control reaches the closing right brace of the body at line 50, so execution continues with the test of the while’s condition (line 42). The condition uses the most recent grade input by the user to determine whether the loop’s body should execute again. The value of variable grade is always input from the user immediately before the application tests the while condition. This allows the application to determine whether the value just input is the sentinel value before the application processes that value (i.e., adds it to the total). If the sentinel value is input, the loop terminates; the application does not add –1 to the total.

Good Programming Practice 5.6

In a sentinel-controlled loop, the prompts requesting data entry should explicitly remind the user of the sentinel value.

Notice the while statement’s block in Fig. 5.9 (lines 43–50). 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 next grade from user
Console.Write( "Enter grade or -1 to quit: " );
grade = Convert.ToInt32( Console.ReadLine() );

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

Error-Prevention Tip 5.3

Omitting the braces that delimit a block can lead to logic errors, such as infinite loops. To prevent this problem, some programmers enclose the body of every control statement in braces even if the body contains only a single statement.

After the loop terminates, the if...else statement at lines 54–65 executes. The condition at line 54 determines whether any grades were input. If none were input, the else part (lines 64–65) of the if...else statement executes and displays the message "No grades were entered", and the method returns control to the calling method.

If at least one grade was entered, line 57 of Fig. 5.9 calculates the average of the grades. Recall from Fig. 5.6 that integer division yields an integer result. Even though variable average is declared as a double (line 30), the calculation

average = total / gradeCounter;

loses the division’s fractional part before the result is assigned to average. This occurs because total and gradeCounter are both integers, and integer division yields an integer result. To perform a floating-point calculation with integer values, we must temporarily treat these values as floating-point numbers for use in the calculation. C# provides the unary cast operator to accomplish this task. Line 57 uses the (double) cast operator—which has higher precedence than the arithmetic operators—to create a temporary floating-point copy of its operand total (which appears to the right of the operator). Using a cast operator in this manner is called explicit conversion. The value stored in total is still an integer.

The calculation now consists of a floating-point value (the temporary double version of total) divided by the integer gradeCounter. C# knows how to evaluate only arithmetic expressions in which the operands’ types are identical. To ensure that the operands are of the same type, C# performs an operation called promotion (or implicit conversion) on selected operands. For example, in an expression containing values of the types int and double, the int values are promoted to double values for use in the expression. In this example, the value of gradeCounter is promoted to type double, then floating-point division is performed and the result of the calculation is assigned to average. As long as the (double) cast operator is applied to any variable in the calculation, the calculation will yield a double result.

Common Programming Error 5.6

A cast operator can be used to convert between simple numeric types, such as int and double, and between related reference types (as we discuss in Chapter 12, OOP: Polymorphism, Interfaces and Operator Overloading). Casting to the wrong type may cause compilation or runtime errors.

Cast operators are available for all simple types. We’ll discuss cast operators for reference types in Chapter 12. The cast operator is formed by placing parentheses around the name of a type. This operator is a unary operator (i.e., an operator that takes only one operand). In Chapter 3, we studied the binary arithmetic operators. C# also supports unary versions of the plus (+) and minus (−) operators, so you can write expressions like +5 or -7. Cast operators associate from right to left and have the same precedence as other unary operators, such as unary + and unary -. This precedence is one level higher than that of the multiplicative operators *, / and %. (See the operator precedence chart in Appendix A.) We indicate the cast operator with the notation (type) in our precedence charts, to indicate that any type name can be used to form a cast operator.

Line 62 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 WriteLine’s format item (line 62) indicates that variable average’s value should be displayed as a real number. By default, numbers output with F have two digits to the right of the decimal point. The number of decimal places to the right of the decimal point is also known as the number’s precision. Any floating-point value output with F will be rounded to the hundredths position—for example, 123.457 will be rounded to 123.46, and 27.333 will be rounded to 27.33. In this application, the three grades entered during the sample execution of class GradeBookTest (Fig. 5.10) total 263, which yields the average 87.66666.... The format item rounds the average to the hundredths position, and the average is displayed as 87.67.

 1   // Fig. 5.10: GradeBookTest.cs
 2   // Create GradeBook object and invoke its DetermineClassAverage method.
 3   public class GradeBookTest
 4   {
 5      public static void Main( string[] args )
 6      {
 7         // create GradeBook object myGradeBook and
 8         // pass course name to constructor
 9         GradeBook myGradeBook = new GradeBook(
10            "CS101 Introduction to C# Programming" );
11
12         myGradeBook.DisplayMessage(); // display welcome message
13         myGradeBook.DetermineClassAverage(); // find average of grades
14      } // end Main
15   } // end class GradeBookTest

Welcome to the grade book for
CS101 Introduction to C# Programming!

Enter grade or -1 to quit: 96
Enter grade or -1 to quit: 88
Enter grade or -1 to quit: 79
Enter grade or -1 to quit: -1

Total of the 3 grades entered is 263
Class average is 87.67

The complete second refinement of the pseudocode appears in Fig. 5.11. Notice that blank lines are also used to set off the while statement for readability. This pseudocode is now sufficiently refined for conversion to C#. The program that implements the pseudocode algorithm and sample outputs are shown in Fig. 5.12.

 1   // Fig. 5.12: Analysis.cs
 2   // Analysis of examination results, using nested control statements.
 3   using System;
 4
 5   public class Analysis
 6   {
 7      public static void Main( string[] args )
 8      {
 9         // initialize variables in declarations   
10         int passes = 0; // number of passes       
11         int failures = 0; // number of failures   
12         int studentCounter = 1; // student counter
13         int result; // one exam result from user
14
15         // process 10 students using counter-controlled repetition
16         while ( studentCounter <= 10 )
17         {
18            // prompt user for input and obtain a value from the user
19            Console.Write( "Enter result (1 = pass, 2 = fail): " );
20            result = Convert.ToInt32( Console.ReadLine() );
21
22            // if...else nested in while                     
23            if ( result == 1 ) // if result 1,               
24               passes = passes + 1; // increment passes      
25            else // else result is not 1, so                 
26               failures = failures + 1; // increment failures
27
28            // increment studentCounter so loop eventually terminates
29            studentCounter = studentCounter + 1;
30         } // end while
31
32         // termination phase; prepare and display results
33         Console.WriteLine( "Passed: {0}
Failed: {1}", passes, failures );
34
35         // determine whether more than 8 students passed
36         if ( passes > 8 )
37            Console.WriteLine( "Bonus to instructor!" );
38      } // end Main
39   } // end class Analysis

Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 2
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Passed: 9
Failed: 1
Bonus to instructor!

Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 2
Enter result (1 = pass, 2 = fail): 2
Enter result (1 = pass, 2 = fail): 2
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 1
Enter result (1 = pass, 2 = fail): 2
Enter result (1 = pass, 2 = fail): 2
Passed: 5
Failed: 5

This example contains only one class, with method Main performing all the class’s work. In this chapter and in Chapter 4, you’ve seen examples consisting of two classes—one class containing methods that perform useful tasks and one containing method Main, which creates an object of the other class and calls its methods. Occasionally, when it makes no sense to try to create a reusable class, we’ll use a mechanical example contained entirely within the Main method of a single class.

Lines 10–13 of Fig. 5.12 declare the variables that method Main uses to process the examination results. Several of these declarations use C#’s ability to incorporate variable initialization into declarations (passes is assigned 0, failures is assigned 0 and studentCounter is assigned 1).

The while statement (lines 16–30) loops 10 times. During each repetition, the loop inputs and processes one exam result. Notice that the if...else statement (lines 23–26) for processing each result is nested in the while statement. If the result is 1, the if...else statement increments passes; otherwise, it assumes the result is 2 and increments failures. Line 29 increments studentCounter before the loop condition is tested again at line 16. After 10 values have been input, the loop terminates and line 33 displays the number of passes and the number of failures. Lines 36–37 determine whether more than eight students passed the exam and, if so, outputs the message "Bonus to instructor!".

Figure 5.12 shows the input and output from two sample executions of the application. During the first sample execution, the condition at line 36 is true—more than eight students passed the exam, so the application outputs a message indicating that the instructor should receive a bonus.

Error-Prevention Tip 5.4

Initializing local variables when they’re declared helps you avoid compilation errors that might arise from attempts to use uninitialized data. While C# does not require that local-variable initializations be incorporated into declarations, it does require that local variables be initialized before their values are used in an expression.