course.wilkes.edu/CS125Labs
Welcome to the site for CS 125 labs!

Lab 6: Repetitive Execution

Introduction

We have seen that the C++ if and switch statements use a condition (an expression that evaluates to true or false) to permit a program to execute statements selectively. For example, we could use the code fragment:

   if (op2 != 0)
      return (op1 / op2);
   else
   {
      cout << "\nError: Divide by zero attempted !\n";
      return 0;
   }

In addition to facilitating selection, most modern programming languages also utilize conditions to permit statements to be executed repeatedly. These repetitive execution statements typically permit a set of statements to be executed over and over, so long as some condition evaluates to true.

As an example use of this capability, suppose that we have a list of lengths that we need to convert from English- to metric-system measurements. Without repetition, converting these lengths requires that we execute the conversion program a separate time for each value on the list. However, by adding a repetitive execution statement to that program, we can convert each value in the list with a single execution of the program.

C++ provides four different loops (well, three, actually) that we will examine in this exercise. These are called the while loop, the do loop, the for loop, and what we call the forever loop.

Getting Started

Today's exercise is to make a calculator program that has more functionality and is more user-friendly than the one we wrote in the last exercise. More precisely, the skeleton program calculate2.cpp differs from our previous version by supporting a fifth calculator function: the exponentiation operation. Follow the usual procedure of creating a 6 directory for this exercise, save a copy of calculate.cpp there, and then personalize the opening documentation of the file.

You may recall that exponentiation is available in C++ via the function pow() in the cmath library. Just for today (to learn about loops), we will not use pow(), but will instead pretend that we are C++ implementers and write our own exponentiation function, called Power().

Since Power() performs an operation that already exists in a library, we will declare and define it within our source file, rather than in a library.

The Exponentiation Operation

The exponentiation operation should be a familiar one, since the expression

   x^n

   Power(x, n)

Function Design

As usual, we begin by using object-centered design to carefully design an exponentiation function. However, before we can describe its behavior, some simple analysis may shed light on what our function must do.

Function Analysis. When faced with a new problem, it is often helpful to solve it "by hand." For example, to calculate Power(2,0), Power(2,1), Power(2,3) and Power(2,5) by hand, we might write:

Power(2,0)	Power(2,1)	Power(2,2)	Power(2,3)
Return 1.	1 * 2 = 2;	1 * 2 = 2;	1 * 2 = 2;
	Return 2;	2 * 2 = 4;	2 * 2 = 4;
		Return 4.	4 * 2 = 8;
			Return 8.

If we examine the pattern in these "by hand" computations, we might construct the following general solution:

   Power(x, n)
   Initialize result to 1.0.
   Set result to result * base. -
   Set result to result * base.  |
   Set result to result * base.  | exponent
   ...                             | times 
   Set result to result * base.  |
   Set result to result * base. -
   Return result.

Function Behavior. We can describe what we want to happen as follows:

   Our function should receive a base value and an exponent value
   from the caller of the function.  It should initialize result
   to one, and then repeatedly multiple result by the base value,
   with the number of repetitions being the exponent value. 
   Our function should then return result.

Function Objects. From our behavioral description, we can identify the following objects:

Description	Type	Kind	Movement	Name
The base value	double	varying	received	base
The exponent value	int	varying	received	exponent
The result value	double	varying	received	result

From this, we can specify the task of our function as follows:

   Receive: base, a double;
            exponent, an int.
   Return: result, a double = base^exponent.

Using this specification, go to calculate.cpp and replace the line

   // ... replace this line with the prototype of Power() ...

   // ... replace this line with the definition of Power() ...

Note that the call to Power() uses int() to convert the double argument op2 to an integer. Without this conversion, our attempt to pass a double argument into an int parameter would result in a compilation error.

Function Operations. From our behavioral description, we have the following operations:

	Description	Defined?	Name	Library?
1	Receive base and exponent	yes	function call mechanism	built-in
2	Initialize result to 1.0	yes	declaration	built-in
3	Set result to result*base	yes	*=	built-in
4	Repeat (3), counting from 1 to exponent	yes	for	built-in
5	Return result	yes	return	built-in

Function Algorithm. We can organize these operations into the following algorithm:

   0. Receive base and exponent from caller.
   1. Initialize result to 1.0;
   2. For each count from 1 to exponent:
       result *= base.
   3. Return result.

Coding

As we have seen before, the C++ for loop is designed to facilitate the counting behavior required by step 2. Recall that its simplified pattern is:

   for (Type Var = Start; Var <= Stop; Var++)
      Statement

Characterizing Loops

The pattern for a C++ for loop is actually more general than we have indicated:

   for (InitializationExpr; Condition; StepExpr)
      Statement

   for (int i = 100; i >= 1; i--)
      cout << 12 * i << endl;

C++ for loops are thus controlled by conditions, just as if statements are controlled by conditions. As we shall see, each of the other C++ loop statements are also controlled by conditions.

A loop may be categorized by when it evaluates its condition, with respect to the statements it repeats:

1. Pretest loops evaluate their condition before the loop's statements.
2. Posttest loops evaluate their condition after the loop's statements.
3. Unrestricted loops evaluate their condition before, after, or within the loop's statements.

The other three C++ loops differ from the for loop in that they are general-purpose loops, designed for problems where the number of repetitions is not known in advance. Why are there three of them? Because

1. The C++ while loop provides a general pretest loop;
2. The C++ do loop provides a general posttest loop; and
3. The C++ forever loop provides a general unrestricted loop.

Getting a Valid Menu Choice

The program in calculate.cpp uses function GetMenuChoice() to get the user's menu choice:

   char GetMenuChoice(const string MENU)
   {
     cout << MENU;
     char choice;
     cin >> choice;
     return choice;
   }

One way to handle such errors is to repeatedly display the menu and input the user's choice, so long as they continue to enter invalid menu choices. Since there is no way to predict in advance how many erroneous choices the user may enter, the for loop is not an appropriate statement to use in this situation.

The general-purpose loops give us a way to handle user errors, but we must decide which one to use. To do so, we can begin by writing a partial algorithm for this problem using a generic Loop statement, in which we don't worry (for the moment) how control will leave the loop:

   Loop:
      a. Display MENU.
      b. Read choice.
   End loop.
   Return choice.

   choice is an invalid menu choice

   choice is a valid menu choice

Since choice is not known until after Step (b), following (b) is the logical place to exit the loop, which we can describe using our termination condition as follows:

   Loop:
      a. Display MENU.
      b. Read choice.
      c. If choice is a valid menu choice, exit the loop.
   End loop.
   Return choice.

In C++, the post-test loop is called the do loop, and its pattern is as follows:

   do
   {
      Statements
   }
   while ( Condition );

1. Statements execute.
2. Condition is evaluated.
3. If Condition is true: control returns to step 1;
   Otherwise, control proceeds to the next statement after the loop.

Since its Condition is not evaluated until after the first execution of Statements, the do loop guarantees that Statements will be executed one or more times. For this reason, the do loop is said to exhibit one-trip behavior. We will therefore implement the preceding algorithm using a do loop.

The notion of a "valid" menu choice is a bit tricky. One way to handle it is to require that the valid menu choices be consecutive letters of the alphabet (e.g., 'a' through 'e'). If we then pass the first and last valid choices to GetMenuChoice() as arguments:

   char operator = GetMenuChoice(MENU, 'a', 'e');

   char GetMenuChoice(const string MENU, char firstChoice, char lastChoice);

   choice < firstChoice || choice > lastChoice

   char GetMenuChoice(const string MENU, char firstChoice, char lastChoice)
   {
     char choice;
     do
     {
       cout << MENU;
       cin >> choice;
     }
     while (choice < firstChoice || choice > lastChoice);
     
     return choice;
   }

Make the necessary modifications to calculate.cpp so that GetMenuChoice() will only return a valid menu choice. Then thoroughly test your code with invalid and valid values. Continue when it works correctly.

Getting Valid Numeric Input

Another potential source of error occurs when our program reads values for op1 and op2 from the keyboard -- the user might enter some non-numeric value. Our current version checks for this using the assert() mechanism and the good() function member of cin:

   cout << "\nNow enter your operands: ";
   double op1, op2;
   cin >> op1 >> op2;
   assert(cin.good());

   do
   {
        // prompt for Op1 and Op2
        // input Op1 and Op2
   }
   while ( !cin.good() );

1. The status of cin is set so that its member function good() will return false (0). This causes a two-fold difficulty:
   1. No input operations can be performed with cin so long as cin.good() returns false.
   2. In order to stop cin.good() from returning false, cin must be explicitly cleared using its clear() member function.
   Together, these imply that we must call cin.clear() before attempting another input operation, or else an infinite loop will result.
2. The non-real input value is left (unread) in the input stream. This means that even after we have cleared the status of cin, the unread input is still sitting in the stream waiting to be read. That is, when the input operation is performed the next repetition of our loop, it will re-read the same non-real value that is still sitting in cin. What we need is a way to somehow "skip over" that value. This can be accomplished using a different function member of cin named ignore(), whose pattern is

         cin.ignore( NumChars, UntilChar );

   When execution reaches this statement, characters in cin will be skipped until NumChars have been skipped, or the character UntilChar is encountered, whichever comes first. Since lines are usually not more than 120 characters in length, and the end of a line of input is marked by the newline character ('\n'), we can use the following call to solve this difficulty:

         cin.ignore(120, '\n');

   Such a call will skip 120 characters in cin, or until a newline character is encountered, whichever comes first.

   a. Display a prompt for two real values; // one or more times
   b. Input op1 and op2;                   // one or more times
   c. cin.clear();                          // only if necessary (i.e., zero or more times)
   d. cin,ignore(120, '\n');                // only if necessary (i.e., zero or more times)

One traditional solution is modify our algorithm to use a pre-test loop in the following way:

   a. Display a prompt for two real values;
   b. Input op1 and op2;
   c. Loop (pretest), so long as cin.good() is false:
      1) cin.clear()
      2) cin.ignore(120, '\n');
      3) Display a prompt for two real values;
      4) Input op1 and op2;
      End loop.

The drawback to this approach is its redundance: steps 3) and 4) are exactly the same as steps a and b. This is not too much of an inefficiency, so long as one does not mind the extra typing. In the final part of this exercise, we will see a way to avoid this redundancy.

Like many other languages the C++ pretest loop is called the while loop, and its pattern is as follows:

   while ( Condition )
      Statement

When execution reaches this statement, the following actions occur:

   I. Condition is evaluated (before Statement is executed);
   II. If Condition evaluates to false, then
         Statement is bypassed, and control proceeds to the statement after the loop;
      Otherwise
         A. Statement is executed; and
         B. execution then returns to step I;
      End if.

In calculate.cpp, add a while loop to encode step c of our modified algorithm, as well as the statements to encode steps 1), 2), 3) and 4). Note that the condition

   !cin.good()

Then translate and thoroughly test what you have written. If you should happen to generate an infinite loop, it can usually be terminated by typing Ctrl-C (pressing the Ctrl and C keys simultaneously). On some systems, it may be necessary to type Ctrl-C several times, or to press Enter and then Ctrl-C. Continue when what you have written makes the entry of numeric values "fool-proof."

continue

Prev | Next | Lab 6

Help

Lab 0

Lab 1

Lab 2

Lab 3a

Lab 3b

Lab 4

Lab 5

Lab 6

Lab 7

Lab 8

Lab 9

Lab 10

Lab 11

Lab 12

Lab 13

Membership

Login