Purpose: 	To loop through a set of instructions until some ending
			or stopping condition is met.


	Pattern: 	Assign a value to all variables involved in the test
				condition
			while the test condition is true 
			{
				Do some set of instructions
				Re-assign a value to at least one of the variables 
					in the test condition
			}


	Example 1: 	int counter = 10; 
			while (counter > 0) 
			{
				/* some set of instructions */
				counter--;
			}



	Example 2: 	int counter = 0; 
			while (counter < 10) 
			{
				/* some set of instructions */
				counter++;
			}



	Example 3: 	bool found = false;
			int counter = 10;

			while ((counter > 0) && !found)
			{ 
				/* some set of instructions that include either 
				decrementing the counter or setting 'found' to true */
			}


	Discussion: 	The middle example is probably the simplest. In it,
			the variable, 'counter' is set to 0 and each time through the
			loop it is incremented by 1. When it has the value 9, the loop
			has executed 10 times. (If you are uncomfortable with this statement,
			count on your fingers starting with the value 0 and not the value 1.) 
			When the counter is incremented again to the value 10, the
			loop stops because the test condition is now false. 


			The third example follows the same pattern except that now there
			are two tests. The variables used in both tests are
			initialized before the loop. Inside the loop either of these variables
			can be changed and sooner or later the changes will cause one
			or both of the tests to go false and the loop will terminate.



			It is very important that all the variables involved in the test
			condition be initialized before the loop begins execution. If
			the reason for this is not clear, be sure you review the section
                        on loops and initialization in Chapter 3, Section IV 
                        of "The Story of C++".


	Note 1: 	If at least one of the variables involved in the test
			condition is not re-assigned a value inside the WHILE loop,
			the loop will never stop. This is called an infinite loop.


	Note 2: 	The test condition variables can be assigned and re-assigned
			using any of a number of valid C++ statements. One common value
			is to have the user enter a value using pattern A1
			(See the next pattern for an example of this.) Another
			common way (as done in the examples above) is to continuously add
			or subtract a value to or from a variable. 


	Note 3: 	Be very careful in combining tests using the logical
			operators. You may want to read the material on '&&'
			and '||' in Chapter 3, Section V of "The Story of C++". 
 


	Note 4: 	There is a 'for' loop pattern, Pattern 'C2', that also meets this
			same purpose.
    
			  
Discussion in "The Story of C++" 
The Basic 'while' Statement
  
Pattern B2: The While Loop with Priming Read       
	Purpose: 	To loop through a set of instructions until the user
			enters some sentinel value.


	Pattern: 	Get value(s) from the user for the variable(s) in the
			test condition
			while the test condition is true 
			{
				Do some set of instructions
				Get value(s) from the user for the variable(s) in the test 
				 condition
			}


	Example 1: 	cout << "PLEASE ENTER COST (0 TO STOP)";
			cin >> cost;
 
			
			while (cost != 0) /* cost is the initialized variable */
                                              and 0 is the sentinel value
			{ 
				// some set of instructions to do something with the cost
				cout << "PLEASE ENTER COST (0 TO STOP)";
				cin >> cost;
			}




	Discussion: 	This pattern may well be the most important one in
			the whole set in the sense that it is used the most and is not
			obvious. The key point to this pattern is the priming read
			or set of priming reads. A priming read is a read (input) instruction
			that gives a value to a variable before that variable is used
			in some kind of a test. In this case, the read takes place before
			the while loop is entered. For further discussion of the priming
			read concept see the Chapter 3, Section IV of "The Story of C++".

			One could actually modify this code so that the input came from
			any 'device' outside the program. For example, instead of the
			input coming from a user typing values at a keyboard, the input
			could come from a sensor device or even from a file. In either
			case, there would still be some sentinel value indicating the
			end of the data.


			It is also possible to combine this pattern and the previous one.
			In such a situation, some of the test condition variables have
			their values changed by a user and some are changed by the code
			itself.


	Note 1: 	While it is common to use 'cin' to get the input(s), one
			can use any other C++ input instruction.

			
	Note 2: 	It is also possible, and in many cases preferable, to use function calls
	        	to retrieve a value entered by a user in place of a cout/cin pair. In that case
			the code might look as follows:

	Example 2: 	cost = GetCost();
						
			while (cost != 0) /* cost is the initialized variable */
                                              and 0 is the sentinel value
			{ 
				// some set of instructions to do something with the cost
				cost = GetCost();
			}




	Note 3: 	Often more than one value is to be input while only one is used as a 
			sentinel value. For example, a program might require that both a cost 
			and a tax rate be entered but that the user only enter a 0 for the cost 
			to exit the program. In other words, the user should not have to type 
			in a tax rate after having entered a 0 for the cost. In that case the
			code might look as follows:

	Example 3: 	cost = GetCost();
						
			while (cost != 0) /* cost is the initialized variable */
                                              and 0 is the sentinel value
			{ 
				 taxRate = GetTaxRate
				// some set of instructions to do something with the cost and 
				   tax rate
				cost = GetCost();
			}



Pattern B3: Loop Until Valid Data Entered            
	Purpose: 	To loop through a set of instructions until the user
			enters a 'valid' value. (This pattern
			is most often used to force a user to enter one of a set of correct
			or acceptable values.)


	Pattern: 	Get a value from the user for the variable used in the
				test condition
			while the variable does not equal one of the 'valid' values
			{
				Display some error message indicating that the value entered is
					not valid
				Get a value from the user for the variable used in the test 
					condition
			}


	Example 1: 	cout << "Please enter a number between
				1 and 100\n";

			cin >> number;


			while (number < 1) || (number > 100)
			{
				cout << "Your number is not between 1 and 100.\n";
				cout << "Please enter a new value.\n";
				cin >> number;
			}


	Example 2: 	cout << "DO YOU WANT TO CONTINUE?" << "/n";
			cout << "PLEASE ENTER (Y)ES OR (N)O";
			cin >> CHOICE;


			while ((choice != 'Y') && (choice != 'y') &&
			       (choice != 'N') && (choice != 'n')) 
			{
				cout << "YOUR ENTRY WAS INVALID"; 
					/* person did not enter 'y' or 'n' */
				cout << "PLEASE ENTER (Y)ES OR (N)O";
				cin >> CHOICE;
			}

	Discussion: 	This is another variation of the basic loop pattern.
			In almost all cases there is only one variable involved in the
			test condition because one is looping until a 'valid' value
			is entered and it would be difficult to keep track of valid values
			for more than one variable at the same time. While there is only one
			variable, there could be more than one test - allowing
			the code to perform a complex set of tests for validity.
    
			  

Pattern B4: Loop Until User Confirms Choice to Quit        
        
	Purpose: 	To loop through a set of instructions until the user
			signals and confirms that he or she is ready to quit.


	Pattern: 	Set a Boolean variable indicating 'done' to FALSE
			while the Boolean variable is false
			{
				Get user's choice
				Process any choices other than quit using 'if' statements 
					or pattern A2

				If choice = quit // if you used pattern A2, use a 'case' statement
				{
					Ask if user is sure
					If answer =     
			
				  
				         
					 yes {

						Boolean variable =           
				
					    
					   true
					}
						}
						}
				

	Example 1: 	bool done;
			char choice;
			done = false;
			while (!done)
			{	choice = GetChoice();
				switch (choice)
				{
				// process the various choices except the one
	   			// for quitting
					case 'Q':
					case 'q':
					cout << "Do you really want to quit (Y) or (N)\n";
					char answ;
					cin >> answ;
					if ((answ == 'Y') || (answ == 'y'))
					{
						done = true;
					}

				// the default choice
			}


	Discussion: 	Although the pattern includes the word 'if', it is more common for 
			this pattern to be implemented with a switch statement. 
			Example
			
			The code for the 'quit' case could include pattern B2.
			As written here, if the user enters anything but 'Y' or 'y',
			the loop continues.
			
			         
			           
			  
See the discussion in "The Story of C++"  
C. The For Loop
The patterns in part 'B' can all be implemented as 'for' loops. Whether one uses the while or for loop to implement an algorithm depends partially on personal preference and partially on which instruction allows for cleaner code. For example, pattern B1 above probably would be better as a 'for' loop and is the first pattern below. On the other hand, pattern B3 is so much cleaner done with a while loop that we won't even bother implementing a for loop version. 
The for loop in other programming languages is often primarily used when one knows beforehand how many times the loop will be executed. While this instruction has been extended in power in C++, this is a good starting point. When you know the number of times a loop will execute, either because it is fixed in the program or because the number of times the loop will execute is calculated or provided by input BEFORE the loop starts, use the 'for' statement. 
Pattern C1: The Basic For Loop     
	Purpose: 	To loop through a set of instructions a set number of
			 times.
			
			         
			           
			  
                           

	Pattern: 	for (variable1 = 0; variable1 < the number of times to loop; variable1++)
			{
			// Some set of instructions
			}


	Example 1: 	for (int i= 0; i < MAX_TIMES; i++)
			{
				// some set of instructions
			}

	Example 2: 	int numTimes;
			cout << "Enter the number of times to loop\n";
			cin >> numTimes;

			for (int count = 0; count < numTimes; count++)
			{
				// some set of instructions
			}


	Discussion: 	The first example uses a constant to determine the number of times 
			the loop executes. The second example has a user enter the number 
			of times. In either case, the number of times to loop is known
			before the loop executes. 

			Compare this pattern with patternB1. Example 1 here is 
			essentially the same as example 2 from pattern B1 except for the 
			constant.


			Example 3 (below) shows a for loop similar to that of example
			1 of pattern B1.


	Example 3: 	for (int i= MAX_TIMES; i > 0; i--)
			{
				// some set of instructions
			}

Pattern C2: The For Loop with Priming Read        
        

	Purpose: 	To loop through a set of instructions until the user
			enters some sentinel value.


	Pattern: 	Get value(s) from the user for the variable(s) in the
				test condition
			for (; a set of tests ; )
			{
				Do some set of instructions
				Get value(s) from the user for the variable(s) in the test condition
			}


	Example 1: 	cout << "PLEASE ENTER COST (0 TO STOP)";
			cin >> cost;

			
			for (; cost > 0; ) /* cost is the initialized variable */
			{ 
				// some set of instructions to do something with the cost
				cout << "PLEASE ENTER COST (0 TO STOP)";
				cin >> cost;
			}


	Discussion: 	Since the initialization is done before the loop and the
			variable is changed inside the loop, only the test
			condition part is coded inside the for loop parentheses. You could
			include the priming read and other inputs inside the code but
			it would not be as readable. (See example 2 below.) 



	Example 2: 	int cost;
			for (cout << "PLEASE ENTER COST (0 TO STOP)",
			cin >> cost; 


			cost > 0;


			cout << "PLEASE ENTER COST (0 TO STOP)",
			cin >> cost ) 

			{
				// some set of instructions

			}
Discussion in "The Story of C++" on the 'for' statement 
Introduction 
Multiple Stopping Conditions and With Arrays 
Advanced 
  
D. Counters, Running Totals and Averages
There are a number of patterns that include some looping pattern and add some further capability. We will take a look at some of them here. Note that the patterns themselves do not stipulate a specific looping pattern. Which one you use depends on the context in which the pattern is used and on personal preferences. The key point is that we are using basic patterns to build more complex patterns. As with programming in general, the trick is to combine patterns so as to correctly use all the elements of the individual patterns while creating an integrated whole. Be sure you study carefully how the basic patterns described above are combined in the patterns and examples below.
 
Pattern D1: The Counter Pattern Using a Loop                                                                                                                     

	Purpose: 	To count the number of times a loop repeats; to implement 
			a counter. 


	Pattern: 	Initialize the Counter Variable to 0
			Use some loop pattern - see Parts 'B' and 'C' above
			
			Inside the loop pattern add the following code:
				Counter Variable++


	Example 1 	int loopCount = 0;
			cout << "PLEASE ENTER COST (0 TO STOP)";
			cin >> cost;
			
			// a loop to count the number of times a real cost is entered
			while (cost != 0) /* cost is the initialized variable */
			{ 
				// some set of instructions to do something with 
				   the cost

				loopCount++;

				cout << "PLEASE ENTER COST (0 TO STOP)";
				cin >> cost;
			}



	Discussion: 	The key to this pattern is contained in the two lines:
				int loopCount = 0;
			and
				loopCount++;


			The rest of the code is purely to make the counter make some sense.
			The first of these lines ensures that the code actually starts
			counting from 0, while the second line does the actual counting.


			Observe how this pattern sits half inside and half outside the
			loop pattern. We do not want to repeatedly initialize the counter
			to 0 so that part sits outside the loop. However, the line that
			increments the counter needs to be inside the loop so that it
			is repeatedly executed. Be careful to put the various elements
			where they belong.


			The variable 'loopCount' in the example starts at 0 and every
			time through the loop it is incremented by one. When the loop
			terminates, 'loopCount' will hold the number of times the loop
			was executed.


			In this example, nothing is done with the value in 'loopCount'.
			In actual programs this value could be output or used as part
			of some calculation as in the average pattern, D3, below.


	Note 1: 	If you had some reason to begin your counter at some value
			other than zero, that would be possible simply by initializing
			the counter to the other value. Usually counter variables are
			initialized to 0 because one wants to start counting from 0. However,
			if, for example, you already knew that 556 of something existed
			and now wanted to count the rest, you might begin the above code
			fragment by initializing the counter to 556. If this was true
			for example 1, the initialization line would then be: 


				int loopCount = 556;


	Note 2:	        If you wanted to count by some value other than one, for
	                example, if you wanted to count by 5, you would change the
		        line:
 	                   count++ ;  (or whatever counter variable you were using)
                    	to:
 	   		   count += 5;  (or whatever value you wanted to count by).

	Note 3: 	It is possible to implement counters where there are no
			explicit loops although this is not as common and it has some
			unique challenges. No code will be provided here but an example
			of such a counter would be code that counted the number of times
			a specific function was called. Outside the function a counter
			would be initialized to 0 (or whatever value was appropriate),
			while, inside, the function itself would be the increment instruction.
			Note the similarity between this and the pattern under discussion.
			In both cases, the initialization takes place outside the code
			that repeats while the incrementing instruction must be inside
			the code that repeats.
 
The Counter Pattern in "The Story of C++" 
  
Pattern D2: The Sum Pattern Using a Loop