C++, as well as many other languages, provide the following three looping constructs: the while, the do-while and the for loop. In this lab, we will only study the characteristics and syntax of the while loop.

 
      howmany = howmany + 1;           // increment counter by one
 

      ++howmany;                       // increment counter by one
 

int howmany;        // declare the variable that will do the counting
howmany = 0;        // initialize to zero

int age;            // age of an individual
int sum;            // used to total/accumulate ages
sum = 0;            // initialize total to zero

cout << "Please enter age of individual: ";
cin >> age;

sum = sum + age;    // add age to existing sum
++howmany;          // count the individual

  

The C++ WHILE Loop
The while loop construct:

• tests a logical expression for exit of the loop at the beginning of the loop. If the logical expression in the while loop evaluates to true, then the statements associated with the loop are executed. If the logical expression evaluates to false, then the statements associated with the loop are not executed. Since the test for exit of the loop is performed before the first instruction in the loop, the while looping construct is called a pre-test loop.
• gives no guarantee that the loop will even execute once since the logical expression used for the loop logical expression is evaluated at the beginning of the loop.
• executes all statements in the loop while some logical expression is true.
• normally variables appearing in the logical expression are initialized (assigned a value) in statements prior to the beginning of the while loop. This is necessary since the logical expression in the while loop is tested before the actual loop is executed.

Sentinel-Controlled WHILE Loop
An event-controlled while loop may use a special data value, sentinel, in conjunction with the logical expression to signal the loop exit. As long as the sentinel value does not meet the logical expression (specified data value), the loop is executed. This looping construct is referred to as a sentinel-controlled while loop.

Example 2. The following is a sentinel-controlled while loop code segment. Line numbers are given for reference only. The while loop reads non-white space until the character q is read. All non-white space characters except the q are counted.

	
20   char letter;                 // storage for letters read
21   int counter;                 // counts the number of letters
22 
23   cin >> letter;               // read the first letter
24   counter = 0;                 // initialize the counter
25   while ( letter != 'q')       // loop until 'q' is read
26   { 
27      ++counter;                // increment letter counter
28      cin >> letter;            // read next letter
29   }
30   cout << "The number of letters read is " << counter << endl;

The loop sentinel value is q and is checked in the logical expression letter != 'q'. The while loop in Example 2 uses a Priming Read--an input statement that appears before the while loop is entered. We say that line 23 primes the while loop. The variable letter can have a value before the while condition could be evaluated.

End-of-file-Controlled WHILE Loop
A while loop is often used to repeatedly read data. When a program uses a stream to read data, the stream state (as described in Chapter 5 Section 5) is set after each read from the input data stream. After the last data item has been read from the input data stream, the data stream state is fine. But the next attempt to read input data from the stream will cause an end-of-file (EOF, for short) to be encountered. At this time the data stream enters a fail state. This state can be used to determine the end of data by using the stream name as a boolean variable to access the current stream state. Thus the stream name, when used in a logical expression, indicates the success of the most recent I/O. The stream state will show failure when the end-of-file is reached. On Unix systems, a ctrl-D keyboard input indicates end of data stream (when reading from the keyboard), and on Window systems a ctrl-Z indicates end of data stream (when reading from the keyboard). When a while loop is used to repeatly read data and the stream state is used to terminate the loop, i.e., the stream state is used as the event in the while loop, the while loop is refered to as an end-of-file-controlled while loop.

Example 3. The following is an end-of-file-controlled while loop code segment. Line numbers are given for reference only.

	
30   float number;       // storage for the number read
31   cin >> number;      // read the first number (priming read)
32   while ( cin )       // loop until failed data stream read
33   {
34      cout << "The number read is " << number << endl;     // display the number read 
35      cin >> number;   // read next number
36   }

The loop logical expression is ( cin ) which indicates the success/failure of the last keyboard input. The while loop in Example 3 uses a priming read--an input statement that appears before the while loop is entered.

Flag-Controlled WHILE Loop A flag is a boolean variable (only can be set to true or false). If a flag is used in a while loop to control the loop execution, then the while loop is referred to as a flag-controlled while loop. Hence, the end-of-file-controlled while loop is a special case of a flag-controlled while loop.

Example 4. The following is a flag-controlled while loop code segment. Line numbers are given for reference only.

	
40   int sum;              // the sum of the numbers read 
41   bool done;            // used to control the while loop
42   int number;           // the number read
43
44   sum = 0;              // initialize the sum
45   done = false;         // initialize the boolean variable done
46   while ( !done )       // loop while not done
47   {
48      cin >> number;     // read next number
49      if ( number > 0 )  // sum number if positive 
50         sum = sum + number;  // sum the number
51      else 
52         done = true;         // terminate the loop
53   }

The loop logical expression ( !done ) indicates the loop should be executed as long as done is false.

The while loop logical expression is number > 0 which indicates the loop should be executed as long as the value of number is greater than zero. Note that this example does basically the same as example 4.