Chapter 5: Controlling Program Flow |
63 |
{
cout << “Argument 1 is greater than argument 2” << endl;
}
else
{
cout << “Argument 1 is not greater than argument 2” << endl;
}
//wait until user is ready before terminating program
//to allow the user to see the program results system(“PAUSE”);
return 0;
}
Here the program reads two integers from the keyboard and compares them. If the expression “arg1 is greater than arg2” is true, control flows to the output statement cout << “Argument 1 is greater than argument 2”. If arg1 is not greater than arg2, control flows to the else clause where the statement cout << “Argument 1 is not greater than argument 2\n” is executed. Here’s what that operation looks like:
Enter arg1: 5
Enter arg2: 6
Argument 1 is not greater than argument 2
Press any key to continue . . .
Executing Loops in a Program
Branch statements allow you to control the flow of a program’s execution from one path of a program or another. This is a big improvement, but still not enough to write full-strength programs.
Consider the problem of updating the computer display. On the typical PC display, 1 million pixels are drawn to update the entire display. A program that can’t execute the same code repetitively would need to include the same set of instructions over and over 1,000 times.
What we really need is a way for the computer to execute the same sequence of instructions thousands and millions of times. Executing the same command multiple times requires some type of looping statements.
64 |
Part I: Introduction to C++ Programming |
Looping while a condition is true
The simplest form of looping statement is the while loop. Here’s what the while loop looks like:
while(condition)
{
// ... repeatedly executed as long as condition is true
}
The condition is tested. This condition could be if var > 10 or if var1 == var2 or anything else you might think of. If it is true, the state ments within the braces are executed. Upon encountering the closed brace, C++ returns control to the beginning, and the process starts over. The effect is that the C++ code within the braces is executed repeatedly as long as the condition is true. (Kind of reminds me of how I get to walk around the yard with my dog until she . . . well, until we’re done.)
If the condition were true the first time, what would make it be false in the future? Consider the following example program:
//WhileDemo - input a loop count. Loop while
//outputting astring arg number of times. #include <cstdio>
#include <cstdlib> #include <iostream> using namespace std;
int main(int nNumberofArgs, char* pszArgs[])
{
//input the loop count int loopCount;
cout << “Enter loopCount: “; cin >> loopCount;
//now loop that many times while (loopCount > 0)
{
loopCount = loopCount - 1;
cout << “Only “ << loopCount << “ loops to go\n”;
}
//wait until user is ready before terminating program
//to allow the user to see the program results system(“PAUSE”);
return 0;
}
WhileDemo begins by retrieving a loop count from the user, which it stores in the variable loopCount. The program then executes a while loop. The while first tests loopCount. If loopCount is greater than zero, the program enters
Chapter 5: Controlling Program Flow |
65 |
the body of the loop (the body is the code between the braces) where it decre ments loopCount by 1 and outputs the result to the display. The program then returns to the top of the loop to test whether loopCount is still positive.
When executed, the program WhileDemo outputs the results shown in this next snippet. Here I entered a loop count of 5. The result is that the program loops 5 times, each time outputting a countdown.
Enter loopCount: 5
Only 4 loops to go
Only 3 loops to go
Only 2 loops to go
Only 1 loops to go
Only 0 loops to go
Press any key to continue . . .
If the user enters a negative loop count, the program skips the loop entirely. That’s because the specified condition is never true, so control never enters the loop. In addition, if the user enters a very large number, the program loops for a long time before completing.
A separate, less frequently used version of the while loop known as the do . . . while appears identical except the condition isn’t tested until the bottom of the loop:
do
{
//...the inside of the loop
}while (condition);
Because the condition isn’t tested until the end, the body of the do . . .
while is always executed at least once.
The condition is only checked at the beginning of the while loop or at the end of the do . . . while loop. Even if the condition ceases to be true at some time during the execution of the loop, control does not exit the loop until the condition is retested.
Using the autoincrement/ autodecrement feature
Programmers very often use the autoincrement ++ or the autodecrement -- operators with loops that count something. Notice, from the following snip pet extracted from the WhileDemo example, that the program decrements the loop count by using assignment and subtraction statements, like this:
66 |
Part I: Introduction to C++ Programming |
// now loop that many times while (loopCount > 0)
{
loopCount = loopCount - 1;
cout << “Only “ << loopCount << “ loops to go\n”;
}
A more compact version uses the autodecrement feature, which does what you may well imagine:
while (loopCount > 0)
{
loopCount--;
cout << “Only “ << loopCount << “ loops to go\n”;
}
The logic in this version is the same as in the original. The only difference is the way that loopCount is decremented.
Because the autodecrement both decrements its argument and returns its value, the decrement operation can actually be combined with the while loop. In particular, the following version is the smallest loop yet.
while (loopCount-- > 0)
{
cout << “Only “ << loopCount << “ loops to go\n”;
}
Believe it or not, the loopcount— > 0 is the version that most C++ program mers would use. It’s not that C++ programmers like being cute (although they do). In fact, the more compact version (which embeds the autoincrement or autodecrement feature in the logical comparison) is easier to read, especially as you gain experience.
Both loopCount— and —loopCount expressions decrement loopCount. The former expression, however, returns the value of loopCount before being decremented; the latter expression does so after being decremented.
How often should the autodecrement version of WhileDemo execute when the user enters a loop count of 1? If you use the pre-decrement version, the value of —loopCount is 0, and the body of the loop is never entered. With the postdecrement version, the value of loopCount— is 1, and control enters the loop.
Beware thinking that the version of the program with the autodecrement command executes faster (since it contains fewer statements). It probably executes exactly the same. Modern compilers are pretty good at getting the number of machine-language instructions down to a minimum, no matter which of the decrement instructions shown here you actually use.