Looping and files

The Increment and

Decrement Operators
• ++ is the increment operator.

It adds one to a variable.

val++; is the same as val = val + 1;

• ++ can be used before (prefix) or after

(postfix) a variable:
++val; val++;
 The Increment and
Decrement Operators
• -- is the decrement operator.

It subtracts one from a variable.

val--; is the same as val = val - 1;

• -- can be also used before (prefix) or

after (postfix) a variable:
--val; val--;
(Program Continues)
 Prefix vs. Postfix
• ++ and -- operators can be used in
complex statements and expressions
• In prefix mode (++val, --val) the
operator increments or decrements, then
returns the value of the variable
• In postfix mode (val++, val--) the
operator returns the value of the variable,
then increments or decrements
 Prefix vs. Postfix - Examples

int num, val = 12;

cout << val++; // displays 12,
// val is now 13;
cout << ++val; // sets val to 14,
// then displays it
num = --val; // sets val to 13,
// stores 13 in
num
num = val--; // stores 13 in num,
// sets val to 12
Notes on Increment, Decrement
• Can be used in expressions:
result = num1++ + --num2;
• Must be applied to something that has a location
in memory. Cannot have:
result = (num1 + num2)++;
• Can be used in relational expressions:
if (++num > limit)
pre- and post-operations will cause different
comparisons

Very important to know about these notes!!!

Introduction to Loops:
The while Loop
 Why do we need loops?
• Previous structures allow us to execute a
statement at most one time!
• Sometimes we want to execute it multiple times!
• To learn 3 loops
– While
– Do – while
– For
– Know their strengths and weakness
 Introduction to Loops:
The while Loop
• Loop: a control structure that causes a
statement or statements to repeat
• General format of the while loop:
while (expression)
statement; //single or
block
• statement; can also be a block of
statements enclosed in { }
 while Loop – How It Works
while (expression)
statement;
• expression is evaluated
– if true, then statement is executed, and
expression is evaluated again
– if false, then the the loop is finished and program
statements following statement execute
– What makes it different from if statement?
if (expression)
statement;
The Logic of a while Loop
How the Loop in Lines
9 through 13
Works
Flowchart of the Loop
 while is a Pretest Loop
• expression is evaluated before the loop
executes. The following loop will never
execute:

int number = 6;
while (number <= 5)
{
cout << "Hello\n";
number++;
}
 Watch Out for Infinite Loops
• The loop must contain code to make
expression become false
• Otherwise, the loop will have no way of
stopping
• Such a loop is called an infinite loop,
because it will repeat an infinite number of
times
 An Infinite Loop

int number = 1;
while (number <= 5)
{
cout << "Hello\n";
}
Using the while Loop for
Input Validation
Using the while Loop for
Input Validation
• Input validation is the process of
inspecting data that is given to the
program as input and determining whether
it is valid.

• The while loop can be used to create input

routines that reject invalid data, and repeat
until valid data is entered.
Using the while Loop for
Input Validation
• Here's the general approach, in
pseudocode:

Read an item of input.

While the input is invalid
Display an error message.
Read the input again.
End While
 Input Validation Example

cout << "Enter a number less than 10: ";

cin >> number;
while (number >= 10)
{
cout << "Invalid Entry!"
<< "Enter a number less than 10: ";
cin >> number;
}
Flowchart
Input Validation Example from
Program 5-4
Counters
 Counters
• Counter: a variable that is incremented or
decremented each time a loop repeats
• Can be used to control execution of the
loop (also known as the loop control
variable)
• Must be initialized before entering loop
The do-while Loop
 The do-while Loop
• do-while: a posttest loop – execute the
loop, then test the expression
• General Format:
do
statement; // or block in {
}
while (expression);

• Note that a semicolon is required after

(expression)
The Logic of a do-while Loop
 do-while Example

int x = 1;
do
{
cout << x << endl;
} while(x < 0);

Although the test expression is false, this loop will

execute one time because do-while is a posttest
loop.
 do-while Loop Notes
• Loop always executes at least once
• Execution continues as long as
expression is true, stops repetition
when expression becomes false
• Useful in menu-driven programs to bring
user back to menu to make another choice
(see Program 5-7 in the book)
 The for Loop

• Useful for counter-controlled loop

• General Format:

for(initialization; test; update)

statement; // or block in { }

• No semicolon after 3rd expression or after the )

 for Loop - Mechanics

for(initialization; test; update)

statement; // or block in { }

1) Perform initialization
2) Evaluate test expression
– If true, execute statement
– If false, terminate loop execution
3) Execute update, then re-evaluate test
expression
 for Loop - Example

int count;

for (count = 1; count <= 5; count++)

cout << "Hello" << endl;
A Closer Look
at the Previous
Example
Flowchart for the Previous
Example
A Closer Look at Lines 13
through 14 in Program 5-8
Flowchart for Lines 13 through
14 in Program 5-8
 When to Use the for Loop

• In any situation that clearly requires

– an initialization
– a false condition to stop the loop
– an update to occur at the end of each iteration
 The for Loop is a Pretest Loop
• The for loop tests its test expression
before each iteration, so it is a pretest
loop.
• The following loop will never iterate:

for (count = 11; count <= 10; count++)

cout << "Hello" << endl;
 for Loop - Modifications
• You can have multiple statements in the
initialization expression.
Separate the statements with a comma:
Initialization Expression
int x, y;
for (x=1, y=1; x <= 5; x++)
{
cout << x << " plus " << y
<< " equals " << (x+y)
<< endl;
}
 for Loop - Modifications
• You can also have multiple statements in the
update expression. Separate the statements with
a comma:
Update Expression
int x, y;
for (x=1, y=1; x <= 5; x++, y++)
{
cout << x << " plus " << y
<< " equals " << (x+y)
<< endl;
}
 for Loop - Modifications

• You can omit the initialization

expression if it has already been done:

int sum = 0, num = 1;

for (; num <= 10; num++)
sum += num;
Note: You also can omit update expression,
moving it to the for loop body!
 for Loop - Modifications

• You can declare variables in the

initialization expression:

int sum = 0;
for (int num = 0; num <= 10; num++)
sum += num;

The scope of the variable num is the for loop.

Keeping a Running Total
 Keeping a Running Total

• running total: accumulated sum of numbers from

each repetition of loop
• accumulator: variable that holds running total
int sum=0, num=1; // sum is the
while (num <= 10) // accumulator
{ sum += num;
num++;
}
cout << "Sum of numbers 1 – 10 is"
<< sum << endl;
(Program Continues)
Sentinels
 Sentinels
• sentinel: value in a list of values that
indicates end of data

• Special value that cannot be confused with

a valid value, e.g., -999 for a test score

• Used to terminate input when user may not

know how many values will be entered
(Program Continues)
Deciding Which Loop
to Use
 Deciding Which Loop to Use
• while: pretest loop; loop body may not
be executed at all

• do-while: posttest loop; loop body will

always be executed at least once

• for: pretest loop with initialization and

update expression; useful with counters,
or if precise number of repetitions is
needed
Nested Loops
 Nested Loops

• A nested loop is a loop inside the body of

another loop
• Inner (inside), outer (outside) loops:

for (row=1; row<=3; row++) //outer

for (col=1; col<=3; col++)//inner
cout << row * col << endl;
Lines from Program 5-14
 Nested Loops - Notes
• Inner loop goes through all repetitions for
each repetition of outer loop

• Inner loop repetitions complete sooner

than outer loop

• Total number of repetitions for inner loop is

product of number of repetitions of the two
loops.
Breaking Out of a Loop
 Breaking Out of a Loop
• Can use break to terminate execution of a
loop

• Use sparingly if at all – makes code harder

to understand and debug
(Not really?)
• When used in an inner loop, terminates
that loop only and goes back to outer loop
5.13 The continue Statement
 The continue Statement
• Can use continue to go to end of loop
and prepare for next repetition
– while, do-while loops: go to test, repeat
loop if test passes
– for loop: perform update step, then test,
then repeat loop if test passes
• Use sparingly – like break, can make
program logic hard to follow
Using a Loop to Read Data from a
File
Using a Loop to Read
Data from a File
• The stream extraction operator >> returns
true when a value was successfully read,
false otherwise

• Can be tested in a while loop to continue

execution as long as values are read from
the file:
while (inputFile >> number) ...