Why Is Repetition Needed?

• Repetition allows efficient use of variables.

• It lets you process many values using a small number
of variables.
• For example, to add five numbers:
– Inefficient way: Declare a variable for each number, input
each number and add them.
– Efficient way: Create a loop that reads a number into a
variable and adds it to another variable that contains the
running total of the numbers.
Example: Inefficient Way of Adding
Five Numbers
Example: Efficient Way of Adding Five
Numbers
Three Kinds of Loops
 for Loop
• for loop: also called a counted loop.
• Syntax of the for statement:
 for Loop (cont.)
• The initial statement is executed only once, when
execution of the for loop begins.
• The loop condition is checked at the beginning of each
repetition. If it is true, the loop is repeated. If it is false,
control passes to the first statement after the end of the loop.
• The update statement is executed at the end of each
repetition.
for Loop (cont’d.)
for Loop (cont’d.)
for Loop (cont’d.)
 for Loop (cont’d.)
• The following is a legal (but infinite) for loop:
for (;;)
cout << "Hello" << endl;
• The following is also legal, but probably not what the
programmer wanted:
for Loop (cont’d.)
for Loop (cont’d.)
 for Loop (cont’d.)
• As expressions, they can, however, make use of the comma operator (,): This
operator is an expression separator, and can separate multiple expressions
where only one is generally expected. For example, using it, it would be
possible for a for loop to handle two counter variables, initializing and
increasing both:
for ( n=0, i=100 ; n!=i ; ++n, --i ){// whatever
here...}
This loop will execute 50 times if neither n or i are modified within the loop:
 for Loop (cont’d.)
Example: A for loop with no increment
#include <iostream>
using namespace std;
int main()
{
int x;

for(x=0; x != 123; ) {
cout << "Enter a number: ";
cin >> x;
}
return 0;
}
 for Loop (cont’d.)
• Example: The body of a for loop can be empty
#include <iostream>
using namespace std;
int main()
{
int i;
int sum = 0;
// sum the numbers from 1 through 10
for(i=1; i <= 10; sum += i++) ;

cout << "Sum is " << sum;

return 0;
}
 while Loop
• Syntax of the while statement:

• statement can be simple or compound.

• expression acts as a decision maker and is
usually a logical expression.
• statement is called the body of the loop.
• The parentheses are part of the syntax.
while Loop (cont’d.)

18
while Loop (cont’d.)

19
 while Loop (cont’d.)
• The variable i in Example 5-1 is called the loop
control variable (LCV).

• Infinite loop: continues to execute endlessly.

Infinite loops are generally undesirable.
– They’re avoided by including statements in the loop
body that assure the exit condition is eventually false.
20
while Loop (cont’d.)
Four Common Ways of Using while
Loops
• There are many ways to use while loops.
• The following slides discuss four common ways. These
differ mainly in the value that is used for the loop
control variable:
• Counter-controlled while loops
• Sentinel-controlled while loops
• Flag-controlled while loops
• EOF-controlled while loops
Case 1: Counter-Controlled while Loops
• Use a counter-controlled while loop when you
know exactly how many times the statements
need to be executed.
Case 2: Sentinel-Controlled while Loops
• In a sentinel-controlled while loop, the
condition checks to see whether a variable is
equal to a special value called the sentinel value.
 Example 5-5: Telephone Digits
• Example 5-5 provides an example of a sentinel-
controlled loop.
• The program converts uppercase letters to their
corresponding telephone digit.
Case 3: Flag-Controlled while Loops
• Flag-controlled while loop: uses a bool
variable to control the loop.
 Number Guessing Game
• Example 5-6 implements a number guessing
game using a flag-controlled while loop.
• It also uses the function rand of the header file
cstdlib to generate a random number.
– rand() returns an int value between 0 and 32767
– To convert to an integer >= 0 and < 100:
• rand() % 100
Case 4: EOF-Controlled while Loops
• EOF stands for end-of-file.
• An EOF-controlled while loop reads data from a
file until it encounters a special end-of-file
character that is automatically included at the
end every file on a disk.
 eof Function
• The function eof can determine the end of file
status.
• eof is a member of data type istream.
• Syntax for the function eof:

where istreamVar is an input stream variable,

such as cin.
 More on Expressions in while
Statements
• The expression in a while statement can be
complex.
– Example:
while ((noOfGuesses < 5) && (!isGuessed))
{
. . .
}
 do…while Loop
• Syntax of a do...while loop:

• The statement executes first, and then the

expression is evaluated.
– As long as expression is true, loop continues.
• To avoid an infinite loop, body must contain a
statement that makes the expression false.
 do…while Loop (cont’d.)
• The statement can be simple or compound.
• Loop always iterates at least once.
do…while Loop (cont’d.)
do…while Loop (cont’d.)
do…while Loop (cont’d.)
 Choosing the Right Kind of Loop
• All three loops have their place in C++.
– If you can determine in advance the number of
repetitions needed, the for loop is the best
choice.
– If you cannot determine in advance the number of
repetitions needed, and it could be zero, use a
while loop.
– If you cannot determine in advance the number of
repetitions needed, and it is at least one, use a
do...while loop.
 break and continue Statements
• break and continue alter the flow of control.
• break statement is used for two purposes:
– To skip the remainder of a switch structure.
– To exit early from a loop.
• Can eliminate the use of certain (flag) variables.
• After break executes, the program continues
with the first statement after the structure.
Example: Using break in a while
Loop
 break and continue Statements
(cont’d.)
• continue is used in while, for, and
do…while structures.
• When executed in a loop, it skips the remaining
statements in the loop and proceeds with the
loop’s next iteration.
Example: Using continue in a while Loop
 Nested Loops
• To create the following pattern:
*
**
***
****
*****

• We can use the following code:

for (i = 1; i <= 5 ; i++)
{
for (j = 1; j <= i; j++)
cout << "*";
cout << endl;
}
 Debugging Loops
• Loops are harder to debug than sequence and
selection structures.
• While debugging, insert temporary cout
statements in your loop so that you can see how the
values of variables are changing as the loop repeats.
• Most common error associated with loops is off-by-
one.
 Programming Example: Fibonacci
Number
• Consider the following sequence of numbers:
– 1, 1, 2, 3, 5, 8, 13, 21, 34, ....
• This is called a Fibonacci sequence.
• Given the first two numbers of the sequence
(say, a1 and a2)
– nth number an, n >= 3, of this sequence is given by: an
= an-1 + an-2
 Programming Example: Fibonacci
Number (cont’d.)
• Fibonacci sequence
– nth Fibonacci number
– a2 = 1
– a1 = 1
– Determine the nth number an, n >= 3
 Programming Example: Fibonacci
Number (cont’d.)
• Suppose a2 = 6 and a1 = 3
– a3 = a 2 + a 1 = 6 + 3 = 9
– a4 = a3 + a2 = 9 + 6 = 15
• Write a program that determines the nth
Fibonacci number, given the first two numbers.
Programming Example: Input and Output
• Input: first two Fibonacci numbers and the
desired Fibonacci number.
• Output: nth Fibonacci number.
 Programming Example: Problem Analysis
• Algorithm: and Algorithm Design
– Get the first two Fibonacci numbers.
– Get the position, n, of the desired number in the
sequence.
– Calculate the next Fibonacci number.
• Add the previous two elements of the sequence.
– Repeat Step 3 until the nth Fibonacci number is
found.
– Output the nth Fibonacci number.
Programming Example: Variables
 Programming Example: Main Algorithm
• Prompt the user for the first two numbers—that
is, previous1 and previous2.
• Read (input) the first two numbers into
previous1 and previous2.
• Output the first two Fibonacci numbers.
• Prompt the user for the position of the desired
Fibonacci number.
 Programming Example: Main Algorithm
(cont’d.)
• Read the position of the desired Fibonacci number
into nthFibonacci.
– if (nthFibonacci == 1)
The desired Fibonacci number is the first Fibonacci
number; copy the value of previous1 into current.
– else if (nthFibonacci == 2)
The desired Fibonacci number is the second Fibonacci
number; copy the value of previous2 into current.
Programming Example: Main Algorithm
(cont’d.)
– else calculate the desired Fibonacci number as follows:
• Initialize counter to 3 to keep track of which Fibonacci
numbers we’re currently calculating.
• Calculate the next Fibonacci number, as follows:
current = previous2 + previous1;
• Assign the value of previous2 to previous1.
• Assign the value of current to previous2.
• Increment counter.
• Repeat until Fibonacci number is calculated.
Programming Example: Main Algorithm
(cont’d.)
– Here’s the code that implements the algorithm’s
loop.

while (counter <= nthFibonacci)

{
current = previous2 + previous1;
previous1 = previous2;
previous2 = current;
counter++;
}
 Programming Example: Main Algorithm
(cont’d.)
• Output the nthFibonacci number, which is
current.