We now consider two sample applications that demonstrate simple uses of for. The application in Fig. 6.5 uses a for statement to sum the even integers from 2 to 20 and store the result in an int variable called total.

 1   // Fig. 6.5: Sum.cs
 2   // Summing integers with the for statement.
 3   using System;
 4
 5   public class Sum
 6   {
 7      public static void Main( string[] args )
 8      {
 9         int total = 0; // initialize total
10
11         // total even integers from 2 through 20
12         for ( int number = 2; number <= 20; number += 2 )
13            total += number;                              
14
15         Console.WriteLine( "Sum is {0}", total ); // display results
16      } // end Main
17   } // end class Sum

Sum is 110

The initialization and increment expressions can be comma-separated lists that enable you to use multiple initialization expressions or multiple increment expressions. For example, you could merge the body of the for statement in lines 12–13 of Fig. 6.5 into the increment portion of the for header by using a comma as follows:

for ( int number = 2; number <= 20; total += number, number += 2 )
   ; // empty statement

The next application uses the for statement to compute compound interest. Consider the following problem:

This problem involves a loop that performs the indicated calculation for each of the 10 years the money remains on deposit. The solution is the application shown in Fig. 6.6. Lines 9–11 in method Main declare decimal variables amount and principal, and double variable rate. Lines 10–11 also initialize principal to 1000 (i.e., $1000.00) and rate to 0.05. C# treats real-number constants like 0.05 as type double. Similarly, C# treats whole-number constants like 7 and 1000 as type int. When principal is initialized to 1000, the value 1000 of type int is promoted to a decimal type implicitly—no cast is required.

 1   // Fig. 6.6: Interest.cs
 2   // Compound-interest calculations with for.
 3   using  System;
 4
 5   public class  Interest
 6   {
 7      public static void Main( string[] args )
 8      {
 9         decimal amount; // amount on deposit at end of each year
10         decimal principal = 1000; // initial amount before interest
11         double rate = 0.05; // interest rate
12
13         // display headers
14         Console.WriteLine( "Year{0,20}", "Amount on deposit" );
15
16         // calculate amount on deposit for each of ten years  
17         for ( int year = 1; year <= 10; year++ )              
18         {                                                     
19            // calculate new amount for specified year         
20            amount = principal *                               
21               ( ( decimal ) Math.Pow( 1.0 + rate, year ) );   
22                                                               
23            // display the year and the amount                 
24            Console.WriteLine( "{0,4}{1,20:C}", year, amount );
25         } // end for                                          
26      } // end Main
27   } // end class Interest

Year     Amount on deposit
   1             $1,050.00
   2             $1,102.50
   3             $1,157.63
   4             $1,215.51
   5             $1,276.28
   6             $1,340.10
   7             $1,407.10
   8             $1,477.46
   9             $1,551.33
  10             $1,628.89

Line 14 outputs the headers for the application’s two columns of output. The first column displays the year, and the second column displays the amount on deposit at the end of that year. We use the format item {0,20} to output the string "Amount on deposit". The integer 20 after the comma indicates that the value output should be displayed with a field width of 20—that is, WriteLine displays the value with at least 20 character positions. If the value to be output is less than 20 character positions wide (17 characters in this example), the value is right justified in the field by default (in this case the value is preceded by three blanks). If the year value to be output were more than four character positions wide, the field width would be extended to the right to accommodate the entire value—this would push the amount field to the right, upsetting the neat columns of our tabular output. To indicate that output should be left justified, simply use a negative field width.

The for statement (lines 17–25) executes its body 10 times, varying control variable year from 1 to 10 in increments of 1. This loop terminates when control variable year becomes 11. (year represents n in the problem statement.)

Classes provide methods that perform common tasks on objects. In fact, most methods must be called on a specific object. For example, to output a greeting in Fig. 4.2, we called method DisplayMessage on the myGradeBook object. Many classes also provide methods that perform common tasks and cannot be called on objects—they must be called using a class name. Such methods are called static methods. For example, C# does not include an exponentiation operator, so the designers of C#’s Math class defined static method Pow for raising a value to a power. You can call a static method by specifying the class name followed by the member access (.) operator and the method name, as in

ClassName.methodName( arguments )

Console methods Write and WriteLine are static methods. In Chapter 7, you’ll learn how to implement static methods in your own classes.

We use static method Pow of class Math to perform the compound interest calculation in Fig. 6.6. Math.Pow(x, y) calculates the value of x raised to the yth power. The method receives two double arguments and returns a double value. Lines 20–21 perform the calculation a = p (1 + r)ⁿ, where a is the amount, p is the principal, r is the rate and n is the year. Notice that, in this calculation, we need to multiply a decimal value (principal) by a double value (the return value of Math.Pow). C# will not implicitly convert double to a decimal type, or vice versa, because of the possible loss of information in either conversion, so line 21 contains a (decimal) cast operator that explicitly converts the double return value of Math.Pow to a decimal.

After each calculation, line 24 outputs the year and the amount on deposit at the end of that year. The year is output in a field width of four characters (as specified by {0,4}). The amount is output as a currency value with the format item {1,20:C}. The number 20 in the format item indicates that the value should be output right justified with a field width of 20 characters. The format specifier C specifies that the number should be formatted as currency.

Notice that we declared the variables amount and principal to be of type decimal rather than double. Recall that we introduced type decimal for monetary calculations in Section 4.11. We also use decimal in Fig. 6.6 for this purpose. You may be curious as to why we do this. We are dealing with fractional parts of dollars and thus need a type that allows decimal points in its values. Unfortunately, floating-point numbers of type double (or float) can cause trouble in monetary calculations. Two double dollar amounts stored in the machine could be 14.234 (which would normally be rounded to 14.23 for display purposes) and 18.673 (which would normally be rounded to 18.67 for display purposes). When these amounts are added, they produce the internal sum 32.907, which would normally be rounded to 32.91 for display purposes. Thus, your output could appear as

  14.23
+ 18.67
-------
  32.91

but a person adding the individual numbers as displayed would expect the sum to be 32.90. You’ve been warned! For people who work with programming languages that do not support a type for precise monetary calculations, Exercise 6.18 explores the use of integers to perform such calculations.

Good Programming Practice 6.3

Do not use variables of type double (or float) to perform precise monetary calculations; use type decimal instead. The imprecision of floating-point numbers can cause errors that will result in incorrect monetary values.

The body of the for statement contains the calculation 1.0 + rate, which appears as an argument to the Math.Pow method. In fact, this calculation produces the same result each time through the loop, so repeating the calculation in every iteration of the loop is wasteful.

Performance Tip 6.2

In loops, avoid calculations for which the result never changes—such calculations should typically be placed before the loop. [Note: Optimizing compilers will typically place such calculations outside loops in the compiled code.]

Figure 6.9 contains an enhanced version of the GradeBook class introduced in Chapter 4 and further developed in Chapter 5. The version of the class we now present not only calculates the average of a set of numeric grades entered by the user, but uses a switch statement to determine whether each grade is the equivalent of an A, B, C, D or F, then increments the appropriate grade counter. The class also displays a summary of the number of students who received each grade. Figure 6.10 shows sample input and output of the GradeBookTest application that uses class GradeBook to process a set of grades.

 1   // Fig. 6.9: GradeBook.cs
 2   // GradeBook class uses switch statement to count letter grades.
 3   using System;
 4
 5   public class GradeBook
 6   {
 7      private int total; // sum of grades                  
 8      private int gradeCounter; // number of grades entered
 9      private int aCount; // count of A grades             
10      private int bCount; // count of B grades             
11      private int cCount; // count of C grades             
12      private int dCount; // count of D grades             
13      private int fCount; // count of F grades             
14
15      // automatic property CourseName
16      public string CourseName { get; set; }
17
18      // constructor initializes automatic property CourseName;
19      // int instance variables are initialized to 0 by default
20      public GradeBook( string name )
21      {
22         CourseName = name; // set CourseName to name
23      } // end constructor
24
25      // display a welcome message to the GradeBook user
26      public void DisplayMessage()
27      {
28         // CourseName gets the name of the course
29         Console.WriteLine( "Welcome to the grade book for
{0}!
",
30            CourseName );
31      } // end method DisplayMessage
32
33      // input arbitrary number of grades from user
34      public void InputGrades()
35      {
36         int grade; // grade entered by user
37         string input; // text entered by the user
38
39         Console.WriteLine( "{0}
{1}",
40            "Enter the integer grades in the range 0-100.",
41            "Type <Ctrl> z and press Enter to terminate input:" );
42
43         input = Console.ReadLine(); // read user input
44
45         // loop until user enters the end-of-file indicator (<Ctrl> z)
46         while ( input != null )
47         {
48            grade = Convert.ToInt32( input ); // read grade off user input
49            total += grade; // add grade to total
50            ++gradeCounter; // increment number of grades
51
52            // call method to increment appropriate counter
53            IncrementLetterGradeCounter( grade );
54
55            input = Console.ReadLine(); // read user input
56         } // end while
57      } // end method InputGrades
58
59      // add 1 to appropriate counter for specified grade
60      private void IncrementLetterGradeCounter( int grade )
61      {
62         // determine which grade was entered     
63         switch ( grade / 10 )                    
64         {                                        
65            case 9: // grade was in the 90s       
66            case 10: // grade was 100             
67               ++aCount; // increment aCount      
68               break; // necessary to exit switch 
69            case 8: // grade was between 80 and 89
70               ++bCount; // increment bCount      
71               break; // exit switch              
72            case 7: // grade was between 70 and 79
73               ++cCount; // increment cCount      
74               break; // exit switch              
75            case 6: // grade was between 60 and 69
76               ++dCount; // increment dCount      
77               break; // exit switch              
78            default: // grade was less than 60    
79               ++fCount; // increment fCount      
80               break; // exit switch              
81         } // end switch                          
82      } // end method IncrementLetterGradeCounter
83
84      // display a report based on the grades entered by the user
85      public void DisplayGradeReport()
86      {
87         Console.WriteLine( "
Grade Report:" );
88
89         // if user entered at least one grade...
90         if ( gradeCounter != 0 )
91         {
92            // calculate average of all grades entered
93            double average = ( double ) total / gradeCounter;
94
95            // output summary of results
96            Console.WriteLine( "Total of the {0} grades entered is {1}",
97               gradeCounter, total );
98            Console.WriteLine( "Class average is {0:F}", average );
99            Console.WriteLine( "{0}A: {1}
B: {2}
C: {3}
D: {4}
F: {5}",
100              "Number of students who received each grade:
",
101              aCount, // display number of A grades
102              bCount, // display number of B grades
103              cCount, // display number of C grades
104              dCount, // display number of D grades
105              fCount ); // display number of F grades
106        } // end if
107        else // no grades were entered, so output appropriate message
108           Console.WriteLine( "No grades were entered" );
109     } // end method DisplayGradeReport
110  } // end class GradeBook

 1   // Fig. 6.10: GradeBookTest.cs
 2   // Create GradeBook object, input grades and display grade report.
 3
 4   public class GradeBookTest
 5   {
 6      public static void Main( string[] args )
 7      {
 8         // create GradeBook object myGradeBook and
 9         // pass course name to constructor
10         GradeBook myGradeBook = new GradeBook(
11            "CS101 Introduction to C# Programming" );
12
13         myGradeBook.DisplayMessage(); // display welcome message
14         myGradeBook.InputGrades(); // read grades from user                
15         myGradeBook.DisplayGradeReport(); // display report based on grades
16      } // end Main
17   } // end class GradeBookTest

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

Enter the integer grades in the range 0-100.
Type <Ctrl> z and press Enter to terminate input:
99
92
45
100
57
63
76
14
92
^Z

Grade Report:
Total of the 9 grades entered is 638
Class average is 70.89
Number of students who received each grade:
A: 4
B: 0
C: 1
D: 1
F: 3

Class GradeBook (Fig. 6.9) declares instance variables total (line 7) and gradeCounter (line 8), which keep track of the sum of the grades entered by the user and the number of grades entered, respectively. Lines 9–13 declare counter variables for each grade category. Class GradeBook maintains total, gradeCounter and the five letter-grade counters as instance variables so that they can be used or modified in any of the class’s methods.

Like earlier versions of the class, class GradeBook declares automatic property CourseName (line 16) and method DisplayMessage (lines 26–31) to display a welcome message to the user. The class also contains a constructor (lines 20–23) that initializes the course name. The constructor sets only the course name—the remaining seven instance variables are ints and are initialized to 0 by default.

Class GradeBook contains three additional methods—InputGrades, IncrementLetterGradeCounter and DisplayGradeReport. Method InputGrades (lines 34–57) reads an arbitrary number of integer grades from the user using sentinel-controlled repetition and updates instance variables total and gradeCounter. Method InputGrades calls method IncrementLetterGradeCounter (lines 60–82) to update the appropriate letter-grade counter for each grade entered. Class GradeBook also contains method DisplayGradeReport (lines 85–109), which outputs a report containing the total of all grades entered, the average of the grades and the number of students who received each letter grade. Let’s examine these methods in more detail.

Lines 36–37 in method InputGrades declare variables grade and input, which will first store the user’s input as a string (in the variable input), then convert it to an int to store in the variable grade. Lines 39–41 prompt the user to enter integer grades and to type Ctrl + z, then press Enter to terminate the input. The notation Ctrl + z means to simultaneously press both the Ctrl key and the z key when typing in a Command Prompt. Ctrl + z is the Windows key sequence for typing the end-of-file indicator. This is one way to inform an application that there’s no more data to input. If Ctrl + z is entered while the application is awaiting input with a ReadLine method, null is returned. (The end-of-file indicator is a system-dependent keystroke combination. On many non-Windows systems, end-of-file is entered by typing Ctrl + d.) In Chapter 17, Files and Streams, we’ll see how the end-of-file indicator is used when an application reads its input from a file. [Note: Windows typically displays the characters ^Z in a Command Prompt when the end-of-file indicator is typed, as shown in the output of Fig. 6.10.]

Line 43 uses the ReadLine method to get the first line that the user entered and store it in variable input. The while statement (lines 46–56) processes this user input. The condition at line 46 checks whether the value of input is a null reference. The Console class’s ReadLine method will return null only if the user typed an end-of-file indicator. As long as the end-of-file indicator has not been typed, input will not contain a null reference, and the condition will pass.

Line 48 converts the string in input to an int type. Line 49 adds grade to total. Line 50 increments gradeCounter. The class’s DisplayGradeReport method uses these variables to compute the average of the grades. Line 53 calls the class’s IncrementLetterGradeCounter method (declared in lines 60–82) to increment the appropriate letter-grade counter, based on the numeric grade entered.

Method IncrementLetterGradeCounter contains a switch statement (lines 63–81) that determines which counter to increment. In this example, 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 consists of a block that contains a sequence of case labels and an optional default label. These are used in this example to determine which counter to increment based on the grade.

When the flow of control reaches the switch statement, the application evaluates the expression in the parentheses (grade / 10) following keyword switch—this is called the switch expression. The application attempts to match the value of the switch expression with one of the case labels. The switch expression in line 63 performs integer division, which truncates the fractional part of the result. Thus, when we divide any value in the range 0–100 by 10, the result is always a value from 0 to 10. We use several of these values in our case labels. For example, if the user enters the integer 85, the switch expression evaluates to int value 8. If a match occurs between the switch expression and a case (case 8: at line 69), the application executes the statements for that case. For the integer 8, line 70 increments bCount, because a grade in the 80s is a B. The break statement (line 71) causes program control to proceed with the first statement after the switch—in this application, we reach the end of method IncrementLetterGradeCounter’s body, so control returns to line 55 in method InputGrades (the first line after the call to IncrementLetterGradeCounter). This line uses the ReadLine method to read the next line entered by the user and assign it to the variable input. Line 56 marks the end of the body of the while statement that inputs grades (lines 46–56), so control flows to the while’s condition (line 46) to determine whether the loop should continue executing based on the value just assigned to the variable input.

The cases in our switch explicitly test for the values 10, 9, 8, 7 and 6. Note the case labels at lines 65–66 that test for the values 9 and 10 (both of which represent the grade A). Listing case labels consecutively in this manner with no statements between them enables the cases to perform the same set of statements—when the switch expression evaluates to 9 or 10, the statements in lines 67–68 execute. The switch statement does not provide a mechanism for testing ranges of values, so every value to be tested 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 each case.

In C, C++, and many other programming languages that use the switch statement, the break statement is not required at the end of a case. 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 encountered. This is often referred to as “falling through” to the statements in subsequent cases. This frequently leads to logic errors when you forget the break statement. For this reason, C# has a “no fall through” rule for cases in a switch—after the statements in a case, you are required to include a statement that terminates the case, such as a break, a return or a throw. (We discuss the throw statement in Chapter 13, Exception Handling: A Deeper Look.)

If no match occurs between the switch expression’s value and a case label, the statements after the default label (lines 79–80) execute. We use the default label in this example to process all switch-expression values that are less than 6—that is, all failing grades. If no match occurs and the switch does not contain a default label, program control simply continues with the first statement (if there is one) after the switch statement.

Class GradeBookTest (Fig. 6.10) creates a GradeBook object (lines 10–11). Line 13 invokes the object’s DisplayMessage method to output a welcome message to the user. Line 14 invokes the object’s InputGrades method to read a set of grades from the user and keep track of the sum of all the grades entered and the number of grades. Recall that method InputGrades also calls method IncrementLetterGradeCounter to keep track of the number of students who received each letter grade. Line 15 invokes method DisplayGradeReport of class GradeBook, which outputs a report based on the grades entered. Line 90 of class GradeBook (Fig. 6.9) determines whether the user entered at least one grade—this avoids dividing by zero. If so, line 93 calculates the average of the grades. Lines 96–105 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 108 outputs an appropriate message. The output in Fig. 6.10 shows a sample grade report based on 9 grades.

Class GradeBookTest (Fig. 6.10) does not directly call GradeBook method IncrementLetterGradeCounter (lines 60–82 of Fig. 6.9). This method is used exclusively by method InputGrades of class GradeBook to update the appropriate letter-grade counter as each new grade is entered by the user. Method IncrementLetterGradeCounter exists solely to support the operations of class GradeBook’s other methods and thus is declared private. Members of a class declared with access modifier private can be accessed only by members of the class in which the private members are declared. When a private member is a method, it’s commonly referred to as a utility method or helper method, because it can be called only by other members of that class and is used to support the operation of those other members.

Figure 6.11 shows the UML activity diagram for the general switch statement. Every set of statements after a case label normally ends its execution with a break or return statement to terminate the switch statement after processing the case. Typically, you’ll use break statements. Figure 6.11 emphasizes this by including break statements in the activity diagram. The diagram makes it clear that the break statement at the end of a case causes control to exit the switch statement immediately.

Figure 6.11. switch multiple-selection statement UML activity diagram with break statements.

Good Programming Practice 6.4

Although each case and the default label in a switch can occur in any order, place the default label last for clarity.

When using the switch statement, remember that the expression after each case can be only a constant integral expression or a constant string expression—that is, any combination of constants that evaluates to a constant value of an integral or string type. An integer constant is simply an integer value (e.g., −7, 0 or 221). In addition, you can use character constants—specific characters in single quotes, such as 'A', '7' or '$'—which represent the integer values of characters. (Appendix C shows the integer values of the characters in the ASCII character set, which is a popular subset of the Unicode character set used by C#.) A string constant (or string literal) is a sequence of characters in double quotes, such as "Welcome to C# Programming!". For strings, you can also use null.

The expression in each case also can be a constant—a value which does not change for the entire application. Constants are declared with the keyword const (discussed in Chapter 7). C# also has a feature called enumerations, which we also present in Chapter 7. Enumeration constants can also be used in case labels. In Chapter 12, we present a more elegant way to implement switch logic—we use a technique called polymorphism to create applications that are often clearer, easier to maintain and easier to extend than applications using switch logic.

The break statement, when executed in a while, for, do...while, switch, or foreach, causes immediate exit from that statement. Execution typically continues with the first statement after the control statement—you’ll see that there are other possibilities as you learn about additional statement types in C#. Common uses of the break statement are to escape early from a repetition statement or to skip the remainder of a switch (as in Fig. 6.9). Figure 6.12 demonstrates a break statement exiting a for.

 1   // Fig. 6.12: BreakTest.cs
 2   // break statement exiting a for statement.
 3   using System;
 4
 5   public class BreakTest
 6   {
 7      public static void Main( string[] args )
 8      {
 9         int count; // control variable also used after loop terminates
10
11         for ( count = 1; count <= 10; count++ ) // loop 10 times
12         {
13            if ( count == 5 ) // if count is 5,
14               break; // terminate loop
15
16            Console.Write( "{0} ", count );
17         } // end for
18
19         Console.WriteLine( "
Broke out of loop at count = {0}", count );
20      } // end Main
21   } // end class BreakTest

1 2 3 4
Broke out of loop at count = 5

When the if nested at line 13 in the for statement (lines 11–17) determines that count is 5, the break statement at line 14 executes. This terminates the for statement, and the application proceeds to line 19 (immediately after the for statement), which displays a message indicating the value of the control variable when the loop terminated. The loop fully executes its body only four times instead of 10 because of the break.

The continue statement, when executed in a while, for, do...while, or foreach, skips the remaining statements in the loop body and proceeds with the next iteration of the loop. In while and do...while statements, the application evaluates the loop-continuation test immediately after the continue statement executes. In a for statement, the increment expression normally executes next, then the application evaluates the loop-continuation test.

Figure 6.13 uses the continue statement in a for to skip the statement at line 14 when the nested if (line 11) determines that the value of count is 5. When the continue statement executes, program control continues with the increment of the control variable in the for statement (line 9).

 1   // Fig. 6.13: ContinueTest.cs
 2   // continue statement terminating an iteration of a for statement.
 3   using System;
 4
 5   public class ContinueTest
 6   {
 7      public static void Main( string[] args )
 8      {
 9         for ( int count = 1; count <= 10; count++ ) // loop 10 times
10         {
11            if ( count == 5 ) // if count is 5,
12               continue; // skip remaining code in loop
13
14            Console.Write( "{0} ", count );
15         } // end for
16
17         Console.WriteLine( "
Used  continue to skip displaying 5" );
18      } // end Main
19   } // end class ContinueTest

1 2 3 4 6 7 8 9 10
Used continue to skip displaying 5

In Section 6.3, we stated that the while statement can be used in most cases in place of for. One exception occurs when the increment expression in the while follows a continue statement. In this case, the increment does not execute before the application evaluates the repetition-continuation condition, so the while does not execute in the same manner as the for.

Software Engineering Observation 6.2

Some programmers feel that break and continue statements violate structured programming. Since the same effects are achievable with structured programming techniques, these programmers prefer not to use break or continue statements.

Software Engineering Observation 6.3

There’s a tension between achieving quality software engineering and achieving the best-performing software. Often, one of these goals is achieved at the expense of the other. For all but the most performance-intensive situations, apply the following rule: First, make your code simple and correct; then make it fast, but only if necessary.

Suppose that we wish to ensure at some point in an application that two conditions are both true before we choose a certain path of execution. In this case, we can use the && (conditional AND) operator, as follows:

if ( gender == 'F' && age >= 65 )
   ++seniorFemales;

This if statement contains two simple conditions. The condition gender == 'F' determines whether a person is female. The condition age >= 65 might be evaluated to determine whether a person is a senior citizen. The if statement considers the combined condition

gender == 'F' && age >= 65

which is true if and only if both simple conditions are true. If the combined condition is true, the if statement’s body increments seniorFemales by 1. If either or both of the simple conditions are false, the application skips the increment. Some programmers find that the preceding combined condition is more readable when redundant parentheses are added, as in:

( gender == 'F' ) && ( age >= 65 )

The table in Fig. 6.14 summarizes the && operator. The table shows all four possible combinations of false and true values for expression1 and expression2. Such tables are called truth tables. C# evaluates all expressions that include relational operators, equality operators or logical operators to bool values—which are either true or false.

Now suppose we wish to ensure that either or both of two conditions are true before we choose a certain path of execution. In this case, we use the || (conditional OR) operator, as in the following application segment:

if ( ( semesterAverage >= 90 ) || ( finalExam >= 90 ) )
   Console.WriteLine ( "Student grade is A" );

This statement also contains two simple conditions. The condition semesterAverage >= 90 is evaluated to determine whether the student deserves an A in the course because of a solid performance throughout the semester. The condition finalExam >= 90 is evaluated to determine whether the student deserves an A in the course because of an outstanding performance on the final exam. The if statement then considers the combined condition

( semesterAverage >= 90 ) || ( finalExam >= 90 )

and awards the student an A if either or both of the simple conditions are true. The only time the message "Student grade is A" is not displayed is when both of the simple conditions are false. Figure 6.15 is a truth table for operator conditional OR (||). Operator && has a higher precedence than operator ||. Both operators associate from left to right.

The parts of an expression containing && or || operators are evaluated only until it’s known whether the condition is true or false. Thus, evaluation of the expression

( gender == 'F' ) && ( age >= 65 )

stops immediately if gender is not equal to 'F' (i.e., at that point, it’s certain that the entire expression is false) and continues if gender is equal to 'F' (i.e., the entire expression could still be true if the condition age >= 65 is true). This feature of conditional AND and conditional OR expressions is called short-circuit evaluation.

Common Programming Error 6.4

In expressions using operator &&, a condition—which we refer to as the dependent condition—may require another condition to be true for the evaluation of the dependent condition to be meaningful. In this case, the dependent condition should be placed after the other condition, or an error might occur. For example, in the expression (i != 0) && (10 / i == 2), the second condition must appear after the first condition, or a divide-by-zero error might occur.

The boolean logical AND (&) and boolean logical inclusive OR (|) operators work identically to the && (conditional AND) and || (conditional OR) operators, with one exception—the boolean logical operators always evaluate both of their operands (i.e., they do not perform short-circuit evaluation). Therefore, the expression

( gender == 'F' ) & ( age >= 65 )

evaluates age >= 65 regardless of whether gender is equal to 'F'. This is useful if the right operand of the boolean logical AND or boolean logical inclusive OR operator has a required side effect—such as, a modification of a variable’s value. For example, the expression

( birthday == true ) | ( ++age >= 65 )

guarantees that the condition ++age >= 65 will be evaluated. Thus, the variable age is incremented in the preceding expression, regardless of whether the overall expression is true or false.

Error-Prevention Tip 6.4

For clarity, avoid expressions with side effects in conditions. The side effects may look clever, but they can make it harder to understand code and can lead to subtle logic errors.

A complex condition containing the boolean logical exclusive OR (^) operator (also called the logical XOR operator) is true if and only if one of its operands is true and the other is false. If both operands are true or both are false, the entire condition is false. Figure 6.16 is a truth table for the boolean logical exclusive OR operator (^). This operator is also guaranteed to evaluate both of its operands.

The ! (logical negation or not) operator enables you to “reverse” the meaning of a condition. Unlike the logical operators &&, ||, &, | and ^, which are binary operators that combine two conditions, the logical negation operator is a unary operator that has only a single condition as an operand. The logical negation operator is placed before a condition to choose a path of execution if the original condition (without the logical negation operator) is false, as in the code segment

if ( ! ( grade == sentinelValue ) )
   Console.WriteLine( "The next grade is {0}", grade );

which executes the WriteLine call only if grade is not equal to sentinelValue. The parentheses around the condition grade == sentinelValue are needed because the logical negation operator has a higher precedence than the equality operator.

In most cases, you can avoid using logical negation by expressing the condition differently with an appropriate relational or equality operator. For example, the previous statement may also be written as follows:

if ( grade != sentinelValue )
   Console.WriteLine( "The next grade is {0}", grade );

This flexibility can help you express a condition in a more convenient manner. Figure 6.17 is a truth table for the logical negation operator.

Figure 6.18 demonstrates the logical operators and boolean logical operators by producing their truth tables. The output shows the expression that was evaluated and the bool result of that expression. Lines 10–14 produce the truth table for && (conditional AND). Lines 17–21 produce the truth table for || (conditional OR). Lines 24–28 produce the truth table for & (boolean logical AND). Lines 31–36 produce the truth table for | (boolean logical inclusive OR). Lines 39–44 produce the truth table for ^ (boolean logical exclusive OR). Lines 47–49 produce the truth table for ! (logical negation).

 1   // Fig. 6.18: LogicalOperators.cs
 2   // Logical operators.
 3   using System;
 4
 5   public class LogicalOperators
 6   {
 7      public static void Main( string[] args )
 8      {
 9         // create truth table for && (conditional AND) operator
10         Console.WriteLine( "{0}
{1}: {2}
{3}: {4}
{5}: {6}
{7}: {8}
",
11            "Conditional AND (&&)", "false && false", ( false && false ),
12            "false && true", ( false && true ),
13            "true && false", ( true && false ),
14            "true && true", ( true && true ) );
15
16         // create truth table for || (conditional OR) operator
17         Console.WriteLine( "{0}
{1}: {2}
{3}: {4}
{5}: {6}
{7}: {8}
",
18            "Conditional OR (||)", "false || false", ( false || false ),
19            "false || true", ( false || true ),
20            "true || false", ( true || false ),
21            "true || true", ( true || true ) );
22
23         // create truth table for & (boolean logical AND) operator
24         Console.WriteLine( "{0}
{1}: {2}
{3}: {4}
{5}: {6}
{7}: {8}
",
25            "Boolean logical AND (&)", "false & false", ( false & false ),
26            "false & true", ( false & true ),
27            "true & false", ( true & false ),
28            "true & true", ( true & true ) );
29
30         // create truth table for | (boolean logical inclusive OR) operator
31         Console.WriteLine( "{0}
{1}: {2}
{3}: {4}
{5}: {6}
{7}: {8}
",
32            "Boolean logical inclusive OR (|)",
33            "false | false", ( false | false ),
34            "false | true", ( false | true ),
35            "true | false", ( true | false ),
36            "true | true", ( true | true ) );
37
38         // create truth table for ^ (boolean logical exclusive OR) operator
39         Console.WriteLine( "{0}
{1}: {2}
{3}: {4}
{5}: {6}
{7}: {8}
",
40            "Boolean logical exclusive OR (^)",
41            "false ^ false", ( false ^ false ),
42            "false ^ true", ( false ^ true ),
43            "true ^ false", ( true ^ false ),
44            "true ^ true", ( true ^ true ) );
45
46         // create truth table for ! (logical negation) operator
47         Console.WriteLine( "{0}
{1}: {2}
{3}: {4}",
48            "Logical negation (!)", "!false", ( !false ),
49            "!true", ( !true ) );
50      } // end Main
51   } // end class LogicalOperators

Conditional AND (&&)
false && false: False
false && true: False
true && false: False
true && true: True

Conditional OR (||)
false || false: False
false || true: True
true || false: True
true || true: True

Boolean logical AND (&)
false & false: False
false & true: False
true & false: False
true & true: True

Boolean logical inclusive OR (|)
false | false: False
false | true: True
true | false: True
true | true: True

Boolean logical exclusive OR (^)
false ^ false: False
false ^ true: True
true ^ false: True
true ^ true: False

Logical negation (!)
!false: True
!true: False

Figure 6.19 shows the precedence and associativity of the C# operators introduced so far. The operators are shown from top to bottom in decreasing order of precedence.