|
|
|
6.2 Conditional Branching StatementsWhile methods branch unconditionally, often you will want to branch within a method depending on a condition that you evaluate while the program is running. This is known as conditional branching. Conditional branching statements allow you to write logic such as "If you are over 25 years old, then you may rent a car." C# provides a number of constructs that allow you to write conditional branches into your programs; these constructs are described in the following sections. 6.2.1 if StatementsThe simplest branching statement is if. An if statement says, "if a particular condition is true, then execute the statement; otherwise skip it." The condition is a Boolean expression. An expression is a statement that evaluates to a value, and a Boolean expression evaluates to either true or false. The formal description of an if statement is: if (expression ) Statement1 This is the kind of description of the if statement you are likely to find in your compiler documentation. It shows you that the if statement takes an expression (a statement that returns a value) in parentheses, and executes Statement1 if the expression evaluates true. Note that Statement1 can actually be a block of statements within braces, as illustrated in Example 6-2.
Example 6-2. The if statementusing System;
namespace Branching
{
class Test
{
static void Main()
{
int valueOne = 10;
int valueTwo = 20;
int valueThree = 30;
Console.WriteLine("Testing valueOne against valueTwo...");
if ( valueOne > valueTwo )
{
Console.WriteLine(
"ValueOne: {0} larger than ValueTwo: {1}",
valueOne, valueTwo);
}
Console.WriteLine("Testing valueThree against valueTwo...");
if ( valueThree > valueTwo )
{
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
} // end if
} // end Main
} // end class
} // end namespace
In this simple program, you declare three variables, valueOne, valueTwo, and valueThree, with the values 10, 20, and 30, respectively. In the first if statement, you test whether valueOne is greater than valueTwo. if ( valueOne > valueTwo )
{
Console.WriteLine(
"ValueOne: {0} larger than ValueTwo: {1}",
valueOne, valueTwo);
}
Because valueOne (10) is less than valueTwo (20), this if statement fails (the condition returns false), and thus the body of the if statement (the statements within the braces) doesn't execute.
You then test whether valueThree is greater than valueTwo: if ( valueThree > valueTwo )
{
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
}
Since valueThree (30) is greater than valueTwo (20), the test returns true, and thus the statement executes. The statement in this case is the block in which you call the WriteLine() method, shown in bold. The output reflects that the first if fails but the second succeeds: Testing valueOne against valueTwo... Testing valueThree against valueTwo... ValueThree: 30 larger than ValueTwo: 20 6.2.2 Single Statement if BlocksNotice that the if statement blocks shown in Example 6-2 each contain only a single statement, one call to WriteLine(). In such cases, you can leave out the braces enclosing the if block. Thus you might rewrite Example 6-2 as shown in Example 6-3. Example 6-3. Single statements with ifusing System;
namespace Branching
{
class Test
{
static void Main()
{
int valueOne = 10;
int valueTwo = 20;
int valueThree = 30;
Console.WriteLine("Testing valueOne against valueTwo...");
if ( valueOne > valueTwo )
Console.WriteLine(
"ValueOne: {0} larger than ValueTwo: {1}",
valueOne, valueTwo);
Console.WriteLine("Testing valueThree against valueTwo...");
if ( valueThree > valueTwo )
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
} // end Main
} // end class
} // end namespace
It is generally a good idea, however, to use the braces even when your if block has only a single statement. There are two reasons for this advice. First, the code is somewhat easier to read and understand with the braces. Code that is easier to read is easier to maintain.
The second reason for using braces is to avoid a common error: adding a second statement to the if and forgetting to add the braces. Consider the code shown in Example 6-4. The programmer has changed the value of valueThree to 10 and added a second statement to the second if block, as shown in bold. Example 6-4. Adding a second statement to ifusing System;
namespace Branching
{
class Test
{
static void Main()
{
int valueOne = 10;
int valueTwo = 20;
int valueThree = 10;
Console.WriteLine("Testing valueOne against valueTwo...");
if ( valueOne > valueTwo )
Console.WriteLine(
"ValueOne: {0} larger than ValueTwo: {1}",
valueOne, valueTwo);
Console.WriteLine("Testing valueThree against valueTwo...");
if ( valueThree > valueTwo )
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
Console.WriteLine("Good thing you tested again!");
} // end Main
} // end class
} // end namespace
Now, before reading any further, review the code and decide for yourself what the output should be. Don't cheat by looking past this paragraph. Then, when you think you know what the output will be, take a look at this: Testing valueOne against valueTwo... Testing valueThree against valueTwo... Good thing you tested again! Were you surprised? The programmer was fooled by the lack of braces and the indentation. Remember that indentation is whitespace and is ignored by the compiler. From the perspective of the programmer, the second statement ("Good thing . . . ") is part of the if block: if ( valueThree > valueTwo )
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
Console.WriteLine("Good thing you tested again!");
The compiler, however, considers only the first statement after the if test to be part of the if statement. The second statement is not part of the if statement. To the compiler, the if statement looks like this: if ( valueThree > valueTwo )
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
Console.WriteLine("Good thing you tested again!");
If you want the second statement to be part of the if statement, you must use braces, as in the following: if ( valueThree > valueTwo )
{
Console.WriteLine(
"ValueThree: {0} larger than ValueTwo: {1}",
valueThree, valueTwo);
Console.WriteLine("Good thing you tested again!");
}
Because of this potential for confusion, many C# programmers use braces with every if statement, even if the statement is only one line.
6.2.3 if . . . else StatementsOften, you will find that you want to take one set of actions when the condition tests true and a different set of actions when the condition tests false. This allows you to write logic such as "If you are over 25 years old, then you may rent a car; otherwise, you must take the train." The otherwise portion of the logic is executed in the else statement. For example, you can modify Example 6-2 to print an appropriate message whether or not valueOne is greater than valueTwo, as shown in Example 6-5. Example 6-5. The else statementusing System;
namespace Branching
{
class Test
{
static void Main()
{
int valueOne = 10;
int valueTwo = 20;
Console.WriteLine("Testing valueOne against valueTwo...");
if ( valueOne > valueTwo )
{
Console.WriteLine(
"ValueOne: {0} larger than ValueTwo: {1}",
valueOne, valueTwo);
} // end if
else
{
Console.WriteLine(
"Nope, ValueOne: {0} is NOT larger than ValueTwo: {1}",
valueOne, valueTwo);
} // end else
} // end Main
} // end class
} // end namespace
Output:
Testing valueOne against valueTwo...
Nope, ValueOne: 10 is NOT larger than ValueTwo: 20
Because the test in the if statement fails (valueOne is not larger than valueTwo), the body of the if statement is skipped and the body of the else statement is executed. Had the test succeeded, the if statement body would execute and the else statement would be skipped. 6.2.4 Nested if StatementsIt is possible, and not uncommon, to nest if statements to handle complex conditions. For example, suppose you need to write a program to evaluate the temperature and specifically to return the following types of information:
There are many good ways to write this program. Example 6-6 illustrates one approach, using nested if statements. Example 6-6. Nested if statementsusing System;
class Values
{
static void Main()
{
int temp = 32;
if (temp <= 32)
{
Console.WriteLine("Warning! Ice on road!");
if (temp == 32)
{
Console.WriteLine(
"Temp exactly freezing, beware of water.");
}
else
{
Console.WriteLine("Watch for black ice! Temp: {0}", temp);
}
}
}
}
The logic of Example 6-6 is that it tests whether the temperature is less than or equal to 32. If so, it prints a warning: if (temp <= 32)
{
Console.WriteLine("Warning! Ice on road!");
The program then checks whether the temp is equal to 32 degrees. If so, it prints one message; if not, the temp must be less than 32 and the program prints the next message. Notice that this second if statement is nested within the first if, so the logic of the else statement is: "since it has been established that the temp is less than or equal to 32, and it isn't equal to 32, it must be less than 32."
6.2.5 Switch StatementsNested if statements are hard to read, hard to get right, and hard to debug. When you have a complex set of choices to make, the switch statement is a more powerful alternative. The logic of a switch statement is this: "pick a matching value and act accordingly." switch (expression )
{
case constant-expression :
statement
jump-statement
[default: statement ]
}
The expression you are "switching on" is put in parentheses in the head of the switch statement. Each case statement compares a constant value with the expression. The constant expression can be a literal, symbolic, or enumerated constant. The compiler starts with the first case statement and works its way down the list, looking for a value that matches the expression. If a case is matched, the statement (or block of statements) associated with that case is executed. The case block must end with a jump statement. Typically, the jump statement is break, which abruptly ends the entire switch statement. When you execute a break in a switch statement, execution continues after the closing brace of the switch statement. (We'll consider the use of the optional default keyword later in this section.) In the next, somewhat whimsical listing (Example 6-7), the user is asked to choose his political affiliation among Democrat, Republican, or Progressive. To keep the code simple, I'll hardwire the choice to be Republican. Example 6-7. Using a switch statementusing System;
class Values
{
static void Main()
{
const int Democrat = 0;
const int Republican = 1;
const int Progressive = 2;
// hard wire to Republican
int myChoice = Republican;
// switch on the value of myChoice
switch (myChoice)
{
case Democrat:
Console.WriteLine("You voted Democratic.");
break;
case Republican:
Console.WriteLine("You voted Republican.");
break;
case Progressive:
Console.WriteLine("You voted Progressive.");
break;
}
Console.WriteLine("Thank you for voting.");
}
}
Output:
You voted Republican.
Thank you for voting.
Rather than using a complicated if statement, Example 6-7 uses a switch statement. The user's choice is evaluated in the head of the switch statement, and the block of statements that gets executed depends on whatever case matches (in this instance, Republican). The statements between the case statement and the break are executed in series. You can have more than one statement here without braces; in effect the case statement and the closing break statement act as the braces. It is possible that the user will not make a choice among Democrat, Republican, and Progressive. You may want to provide a default case that will be executed whenever no valid choice has been made. Do that with the default keyword, as shown in Example 6-8. Example 6-8. A default statementusing System;
class Values
{
static void Main()
{
const int Democrat = 0;
const int Republican = 1;
const int Progressive = 2;
// hard wire to Republican
int myChoice = 5;
// switch on the value of myChoice
switch (myChoice)
{
case Democrat:
Console.WriteLine("You voted Democratic.\n");
break;
case Republican:
Console.WriteLine("You voted Republican.\n");
break;
case Progressive:
Console.WriteLine("You voted Progressive.\n");
break;
default:
Console.WriteLine("You did not make a valid choice.");
break;
}
Console.WriteLine("Thank you for voting.");
}
}
Output
You did not make a valid choice.
Thank you for voting.
If the user does not choose one of the values that correspond to a case statement, the default statements will execute. In this case, a message is simply printed telling the user he did not make a valid choice. 6.2.6 Falling Through and Jumping to CasesIf two cases will execute the same code, you can create what's known as a "fall through" case, grouping the case statements together with the same code, as shown here: case CompassionateRepublican:
case Republican:
Console.WriteLine("You voted Republican.\n");
Console.WriteLine("Don't you feel compassionate?");
break;
In this example, if the user chooses either CompassionateRepublican or Republican, the same set of statements will be executed. Note that you can only fall through if the first case executes no code. In this example, the first case, CompassionateRepublican, meets that criteria. Thus, you can fall through to the second case. If, however, you want to execute a statement with one case and then fall through to the next, you must use the goto keyword to jump to the next case you want to execute.
For example, if you create a NewLeft party, you might want the NewLeft voting choice to print a message and then fall through to Democrat (that is, continue on with the statements in the Democrat case). You might (incorrectly) try writing the following: case NewLeft:
Console.WriteLine("The NewLeft members are voting Democratic.");
case Democrat:
Console.WriteLine("You voted Democratic.\n");
break;
This code will not compile; it will fail with the error: Control cannot fall through from one case label (case '4:') to another This is a very misleading error message. Control can fall through from one case label to another, but only if there is no code in the first case label.
Because the NewLeft case has a statement, the WriteLine() method, you must use a goto statement to fall through: case NewLeft:
Console.WriteLine("The NewLeft members are voting Democratic.");
goto case Democrat;
case Democrat:
Console.WriteLine("You voted Democratic.\n");
break;
This code will compile and execute as you expect.
6.2.7 Switch on string StatementsIn the previous example, the switch value was an integral constant. C# also offers the ability to switch on a string. Thus, you can rewrite Example 6-8 to switch on the string "NewLeft," as in Example 6-9. Example 6-9. Switching on a stringusing System;
class Values
{
static void Main()
{
String myChoice = "NewLeft";
// switch on the string value of myChoice
switch (myChoice)
{
case "NewLeft":
Console.WriteLine(
"The NewLeft members are voting Democratic.");
goto case "Democrat";
case "Democrat":
Console.WriteLine("You voted Democratic.\n");
break;
case "CompassionateRepublican": // fall through
case "Republican":
Console.WriteLine("You voted Republican.\n");
Console.WriteLine("Don't you feel compassionate?");
break;
case "Progressive":
Console.WriteLine("You voted Progressive.\n");
break;
default:
Console.WriteLine("You did not make a valid choice.");
break;
}
Console.WriteLine("Thank you for voting.");
}
}
|
|
|
|
