This set of Mini-Lab Exercises includes the following:

• Keep on Moving   (Counted Repetition)
• Put the User in the Driver's Seat   (Prompted Input)
• Random Behavior   (RandGen class)

These mini-lab exercises are part of a series of exercises that builds a small program with several fish moving around in an aquarium. In the exercises that precede this one, students will have created three fish of various colors, moved them forward one space (changing the fish's direction when it is about to hit a wall), and displayed them graphically. Students should be familiar with constructing objects, invoking methods, and using conditional statements and logical expressions.

Keep on Moving

Our program would be more interesting if we had the fish move more than just the one time. We can use the Counted Repetition pattern to allow the fish to move for several time slices.

Counted Repetition (Repetition)

You are in a situation in which some action should be repeated a known number (N) of times, where N might be a constant number or a value in a variable. The number of repetitions does not depend on any aspect of the repeated action, i.e., you know the value of N before you start the repetition.

Therefore, use a FOR statement that creates a variable to count the number of times the action has been repeated. The counting variable is created and initialized and then, so long as the action has not been repeated too many times (the "test"), the action is done and the count is incremented (the "step"). Express the test as a Positive Condition if possible. The structure of a FOR loop is:

 for (<initialization> ; <condition> ; <step>)
        <repeated action>

There are two common idioms for controlling the loop. The first is to count from 0 to N-1, which is the idiom used to ensure a Valid Index in a Linear Indexed Traversal (see the Repetition pattern for detailed information on Linear Indexed Traversal). For example, at the beginning of a card game each player is dealt a hand of cards:

for (int i = 0; i < nbrPlayers; i++)
{       dealHand();
}

The second common idiom for controlling the loop is to count from 1 to N. For example,

for (int i = 1; i <= nbrPlayers; i++)
{       dealHand();
}

You might choose to use the second alternative because it corresponds more closely with counting. On the other hand, the Linear Indexed Traversal pattern is a very common, and important, pattern because it is used to step through one of the most common data structures.

WARNING: It is important to note that your loop will have an off-by-one boundary error if you mix the two idioms. If, for example, you write

for (int i = 0; i <= nbrPlayers; i++)             INCORRECT!
{       dealHand();
}

your action will be repeated nbrPlayers+1 times, not nbrPlayers times. If, on the other hand, you write

for (int i = 1; i < nbrPlayers; i++)              INCORRECT!
{       dealHand();
}

your action will be repeated nbrPlayers-1 times. To avoid these kinds of mistakes many people find it easiest to consistently use the Linear Indexed Traversal
(i = 0; i < N; i++)
pattern for counting as well as for accessing indexable structures.

Another alternative is to count down rather than counting up. This alternative and other types of Repetition are described in the complete Repetition Pattern.

Put the User in the Driver's Seat

Our program would be more flexible if we allowed the user to specify how many times they want the simulation to run. We can use a Prompted Input to ask the user to provide the desired number.

Prompted Input

In the Prompted Input pattern, we print a prompt that describes the type of input required from the user and then read in the desired value. A well-written and robust version of this pattern verifies that the input actually provided by the user matches the expectations of the program. For example, if we prompt the user to provide an integer, we should verify that the input is, in fact, a valid integer and not a string, floating point number, or other type. We will return to this full-fledged version of Prompted Input when we discuss writing functions.

In the meantime, we will use a simpler, weaker version of Prompted Input that does not verify the user's input. The structure of this Prompted Input pattern is:

 cout << "String to prompt user: ";
 cin >> inputVariable;

The prompt may be on its own line, in which case the cout statement will end with an endl or \n new-line escape sequence. Alternatively, you may wish the user to enter their data on the same line as the prompt, in which case the prompt should end with one or more spaces.

For example,

int numPlayers;
cout << "How many players will participate?  "
cin >> numPlayers;

Random Behavior

Looking Ahead: