

CS201
Introduction to Programming
Lecture
Handout
Introduction
to programming
Lecture
No. 6
Reading
Material
Deitel
& Deitel C++ How to
Program
chapter
2
2.7,
2.8, 2.9, 2.20
Summary
Repetition
Structure (Loop)
o
Overflow
Condition
o
Sample
Program 1
o
Sample
Program 2
o
Infinite
Loop
o
Properties
of While loop
o
Flow
Chart
o
Sample
Program 3
o
Tips
o
Repetition
Structure (Loop)
In our
day to day life, most of the
things are repeated. Days and nights
repeat themselves
30 times
a month. Four seasons replace
each other every year. We
can see similar
phenomenon
in the practical life. For example, in
the payroll system, some
procedures
are
same for all the
employees. These are
repeatedly applied while dealing with
the
employees.
So repetition is very useful structure in
the programming.
Let's
discuss a problem to understand it thoroughly. We
have to calculate the sum of
first
10 whole
numbers i.e. add the numbers
from 1 to 10. Following
statement may be one
way to do
it.
cout
<< "Sum of first 10 numbers is = "
<< 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 9 +
10;
This
method is perfectly fine as
the syntax is right. The
answer is also correct.
This
procedure
can also be adopted while
calculating the sum of numbers from 1 to
100. We
can
write the above statement
adding all the digits
from 1 to 100. But this
method will not
be
suitable for computing the
sum of numbers from 1 to
1000.The addition of a very
big
number of
digits will result in a very
ugly and boring statement.
Let's analyze it
carefully.
Our first integer is 1, is there
any other way to find
out what is the next
integer?
Page
44
CS201
Introduction to Programming
Yes, we
can add 1 to the integer
and get the next
integer which is 2. To find
the next
integer
(i.e. 3) we add 1 to the previous integer
(i.e. 2) and get the next
integer which is 3.
So
whenever we have to find out
the next integer, we have to
add 1 to the previous
integer.
We have
to calculate the sum of
first 1000 integers by
taking a variable sum
of
type int.
It
is a good
programming practice to initialize
the variable before using it. Here,
we
initialize
the variable sum
with
zero.
int sum =
0;
Now we
get the first integer i.e.
1. We add this to the sum
(sum
becomes 0
+ 1 = 1). Now
get
the next integer which
can be obtained by adding 1 to
the previous integer i.e. 2
and
add it to
the sum
(sum
becomes 1
+ 2 = 3). Get the next
integer by adding 1 to
the
previous
integer and add it to the
sum
(sum
becomes 3
+ 3 = 6) and so on. This
way, we
get
the next integer by adding 1
to the previous integer and
the new integer to the
sum. It
is obvious
that we are repeating this
procedure again and again
i.e. adding 1 to the
previous
integer and add this
new integer to the sum. So
we need some repetition
structure
in the programming language.
There are many looping
constructs in C
Language.
The repetition structure we are
discussing in this lecture is
'while loop
structure'.
`while'
is
also a key word of 'C' so it
cannot be used as a variable
name.
While
means, 'do it until the
condition is true'. The use
of while construct can be
helpful
in
repeating a set of instructions under
some condition. We can also
use curly braces
with
while
just
like we used with if. If we
omit to use the braces
with while
construct,
then
only
one statement after while
will be repeatedly executed.
For good programming
practices,
always use braces with
while
irrespective of
the number of statements in
while
block.
The code will also be
indented inside the while
block as
Indentation makes the
code
easy to understand.
The
syntax of while
construct
is as under:
while (
Logical Expression ) {
statement1;
statement2;
.............
}
The
logical expression contains a
logical or relational operator. While
this logical
expression
is true, the statements will
be executed repeatedly. When this
logical
expression
becomes false, the
statements within the while
block,
will not be executed.
Rather
the next statement in the
program after while
block,
will be executed.
Let's
discuss again the same
problem i.e. calculation of the sum of first
1000 integers
starting
from 1. For this purpose, we
need a variable to store the
sum of integers and
declare a
variable named sum. Always
use the self explanatory variable
names. The
declaration
of the variable sum in this case
is:
int
sum = 0;
Page
45
CS201
Introduction to Programming
The
above statement has performed
two tasks i.e. it declared
the variable sum
of
type int
and
also initialized it with
zero. As it is good programming
practice to initialize all
the
variables
when declared, the above
statement can be written
as:
int
sum;
sum =
0;
Here we
need a variable to store numbers. So we
declare a variable number
of
type int.
This
variable will be used to store
integers.
int
number;
As we
have declared another variable of
int
data
type, so the variables of
same data type
can be
declared in one line.
int
sum, number;
Going
back to our problem, we need to
sum up all the integers
from 1 to 1000. Our
first
integer
is 1. The variable number
is to
be used to store integers, so we
will initialize it by
1 as our
first integer is 1:
number =
1;
Now we
have two variables sum
and
number.
That means we have
two memory
locations
labeled as sum and number
which will be used to store
sum of integers and
integers
respectively. In the variable sum,
we
have to add all the
integers from 1 to
1000.
So we
will add the value of
variable number
into
variable sum,
till
the time the value of
number
becomes 1000. So when the
value of number becomes
1000, we will stop
adding
integers
into sum.
It
will become the condition of
our while loop. We can say
sum the
integers
until integer becomes 1000.
In C language, this condition
can be written as:
while (
number <= 1000 ) {
.........Action
.........
}
The
above condition means, 'perform
the action until the number
is 1000 or less than
1000'.
What will be the Action?
Add the number, the
value of number is 1 initially,
into
sum.
This is a very simple
statement:
sum = sum +
number;
Let's
analyze the above statement
carefully. We did not write
sum
= number; as
this
statement
will replace the contents of
sum
and
the previous value of sum
will be
wasted
as this
is an assignment statement. What we
did? We added the contents
of sum
and
contents
of number
first
(i.e. 0 + 1) and then stored
the result of this (i.e. 1) to
the sum.
Page
46
CS201
Introduction to Programming
Now we
need to generate next
integer and add it to the
sum. How can we get
the next
integer?
Just by adding 1 to the
integer, we will get the
next integer. In `C', we
will write
it
as:
number =
number + 1;
Similarly
in the above statement, we
get the original contents of
number (i.e. 1). Add 1
to
them and
then store the result (i.e.
2) into the number. Now we
need to add this
new
number
into sum:
sum = sum +
number;
We add
the contents of sum
(i.e.
1) to the contents of number (i.e. 1)
and then store
the
result
(i.e. 2) to the sum. Again we
need to get the next
integer which can be
obtained by
adding 1
to the number. In other
words, our action consists of
only two statements
i.e.
add
the number to the sum
and get the next
integer. So our action statements
will be:
sum
= sum + number;
number
= number + 1;
Putting
the action statements in while
construct:
while
( number <= 1000 ) {
sum
= sum + number;
number
= number + 1;
}
Let's
analyze the above while
loop. Initially the contents of
number
is 1.
The condition in
while
loop
(i.e. number
<= 1000) will be
evaluated as true, contents of
sum
and
contents
of number
will be
added and the result
will be stored into sum. Now 1
will be added to
the
contents of number
and
number
becomes
2. Again the condition in while
loop
will be
evaluated
as true and the contents of
sum
will be
added to the contents of number
.The
result
will be stored into sum. Next 1
will be added to the
contents of number
and
number
becomes 3
and so on. When number
becomes
1000, the condition in while
loop
evaluates
to be
true, as we have used <=
(less than or equal to) in
the condition. The contents
of
sum
will be
added to the contents of number
(i.e.
1000) and the result
will be stored into
the
sum. Next 1
will be added to the
contents of number
and
number
becomes
1001. Now
the
condition in while
loop is
evaluated to false, as number
is no
more less than or
equal
to 1000
(i.e. number
has
become 1001). When the
condition of while
loop
becomes false,
loop is
terminated. The control of
the program will go to the
next statement following
the
ending
brace of the while
construct.
After the while
construct,
we can display the
result
using
the cout
statement.
cout
<< " The sum of first
1000 integers starting from 1 is "
<< sum;
The
complete code of the program is as
follows:
/* This
program calculate the sum of
first 1000 integers
*/
#include
<iostream.h>
main()
{
//declaration of
variables
int sum,
number;
Page
47
CS201
Introduction to Programming
//Initialization
of the variables
sum =
0;
number =
1;
// using the while
loop to find out the
sum of first 1000 integers
starting from 1
while(number <=
1000)
{
// Adding
the integer to the contents
of sum
sum =
sum + number;
// Generate
the next integer by adding 1
to the integer
number =
number + 1;
}
cout <<
"The sum of first 1000
integers starting from 1 is " <<
sum;
}
The
output of the program is:
The
sum of first 1000 integers
starting from 1 is 500500
While
construct
is a very elegant and
powerful construct. We have
seen that it is very
easy to
sum first 1000 integers
just with three statements.
Suppose we have to
calculate
the sum
of first 20000 integers. How
can we do that? We just have
to change the
condition
in the while loop (i.e.
number <= 20000).
Overflow
Condition:
We can
change this condition to
10000 or even more. Just try
some more numbers.
How
far can
you go with the limit? We
know that integers are
allocated a fixed space
in
memory
(i.e. 32 bits in most PCs) and we
can not store a number
which requires more
bits
than integer, into a variable of
data type, int. If the
sum of integers becomes
larger
than
this limit (i.e. sum of integers
becomes larger than 32 bits
can store), two things
can
happen
here. The program will
give an error during execution, compiler
can not detect
such
errors. These errors are
known as run time errors.
The second thing is that 32
bits of
the
result will be stored and
extra bits will be wasted, so
our result will not be
correct as
we have
wasted the information. This
is called overflow. When we try to store
larger
information
in, than a data type can
store, overflow condition
occurs. When overflow
condition
occurs either a runtime
error is generated or wrong
value is stored.
Sample
Program 1:
To
calculate the sum of 2000
integers, we will change the
program (i.e. the while
condition)
in the editor and compile it
and run it again. If we need
to calculate the sum
of
first
5000 integers, we will
change the program again in
the editor and compile and
run it
again. We
are doing this work again in
a loop. Change the program in
the editor, compile,
execute
it, again change the
program, compile and execute
it and so on. Are we doing
this
Page
48
CS201
Introduction to Programming
in a
loop? We can make our
program more intelligent so that we don't
need to change the
condition
every time. We can modify
the condition as:
int
upperLimit;
while
(number <= upperLimit)
where
upperLimit is a variable of data type
int. When the value of
upperLimit is 1000,
the
program will calculate the
sum of first 1000 integers.
When the value of upperLimit
is
5000,
the program will calculate
the sum of first 5000
integers. Now we can make it
re
usable
and more effective by requesting
the user to enter the
value for upper
limit:
cout
<< "Please enter the
upper limit for which
you want the sum ";
cin
>> upperLimit;
We don't
have to change our program
every time when the
limit changes. For the sum
of
integers,
this program has become
generic. We can calculate
the sum of any number
of
integers
without changing the
program. To make the display
statement more
understandable,
we can change our cout
statement
as:
cout
<< " The sum of first " <<
upperLimit << " integers is " <<
sum;
Sample
Program 2:
Problem
statement:
Calculate
the sum of even numbers for
a given upper limit of
integers.
Solution:
We
analyze the problem and know
that while statement will be
used. We need to sum
even
numbers only. How can we
decide that a number is even
or not? We know that
the
number
that is divisible by 2 is an even
number. How can we do this
in C language? We
can
say that if a number is
divisible by 2, it means its
remainder is zero, when
divided by
2. To get
a remainder we can use C's
modulus operator i.e. %. We can say
that for a
number if
the expression (number % 2) results in
zero, the number is even.
Putting this in
a
conditional statement:
If ( (
number % 2) == 0 )
The
above conditional statement
becomes true, when the
number is even and false
when
the
number is odd (A number is
either even or odd).
The
complete code of the program is as
follows:
/* This
program calculates sum of
even numbers for a given
upper limit of
integers
*/
#include
<iostream.h>
main()
{
//declaration of
variables
int sum,
number, upperLimit;
//Initialization
of the variables
Page
49
CS201
Introduction to Programming
sum =
0;
number =
1;
// Prompt
the user to enter upper limit of
integers
cout <<
"Please enter the upper
limit for which you want
the sum " ;
cin >>
upperLimit;
// using the while
loop to find out the
sum of first 1000 integers
starting from 1
while(number <=
upperLimit)
{
// Adding
the even integer to the
contents of sum
if ( ( number % 2
) == 0 )
{
sum =
sum + number;
}
// Generate
the next integer by adding 1
to the integer
number =
number + 1;
}
cout <<
"The sum of even numbers of
first " << upperLimit << "
integers starting
from 1 is "
<< sum;
}
The
output of the program is:
Please
enter the upper limit
for which you want
the sum 10
The
sum of even numbers of first
10 integers starting from 1 is 30
Suppose
if we don't have modulus operator in
the C language. Is there any
other way to
find
out the even numbers? We
know that in C integer
division gives the integer
result
and
the decimal portion is
truncated. So the expression (2 *
(number / 2)) gives the
number as
a result, if the number is
even only. So we can change
our condition in if
statement
as:
if ( ( 2 * (
number /2 ) ) == number )
Infinite
Loop:
Consider
the condition in the while
structure
that is (number <= upperLimit)
and in the
while
block
the value of number
is
changing (number = number + 1) to ensure
that the
condition
is tested again next time.
If it is true, the while
block is
executed and so on.
So
in the
while
block
statements, the variable used in
condition must change its
value so that
we have
some definite number of repetitions.
What will happen if we do not
write the
statement
number
= number + 1; in our
program? The value of number
will
not change,
so the
condition in the while
loop
will be true always and
the loop will be
executed
forever.
Such loops in which the
condition is always true are
known as infinite loops
as
there
are infinite repetitions in
it.
Page
50
CS201
Introduction to Programming
Property
of while loop:
In the
above example, if the user
enters 0, as the value for
upper limit. In the
while
condition
we test (number <= upperLimit) i.e.
number is less than or equal
to upperLimit
( 0 ),
this test return false.
The control of the program
will go to the next
statement after
the
while
block.
The statements in while
structure
will not be executed even
for a single
time. So
the property of while loop is
that it may execute zero or
more time.
The
while
loop is
terminated, when the
condition is tested as false.
Make sure that
the
loop
test has an adequate exit.
Always use braces for
the loop structure. If you
forget to
put
the braces, only one
statement after the while
statement
is considered in the while
block.
Flow
Chart:
The
basic structure of while
loop in structured flow
chart is:
At first,
we will draw a rectangle and
write while in it. Then
draw a line to its right
and
use
the decision symbol i.e. diamond diagram.
Write the loop condition in
the diamond
and
draw a line down to diamond
which represents the flow
when the decision is true.
All
the
repeated processes are drawn
here using rectangles. Then
a line is drawn from the
last
process
going back to the while and
decision connection line. We have a
line on the right
side of
diamond which is the exit of
while loop. The while
loop
terminates, when the
loop
condition
evaluates to false and the
control gets out of while
structure.
Here is
the flow chart for
sample program 2:
Page
51
CS201
Introduction to Programming
So far, we
have been drawing flow
charts after coding the program
but actually we have
to draw
the flow chart first
and then start
coding.
Sample
Program 3:
Problem
statement:
Calculate
the factorial of a given
number.
Solution:
The
factorial of a number N is defined
as:
N(N1)(N2).............3.2.1
Page
52
CS201
Introduction to Programming
By
looking at the problem, we can
see that there is a repetition of
multiplication of
numbers.
A loop is needed to write a
program to solve a factorial of a number.
Let's think
in terms
of writing a generic program to calculate
the factorial so that we can
get the
factorial
of any number. We have to
multiply the number with
the next decremented
number
until the number becomes 1.
So the value of number will
decrease by 1 in each
repetition.
Here is
the flow chart for
the factorial.
Here is
the code of the
program.
/*This
program calculates the
factorial of a given
number.*/
#include
<iostream.h>
main()
{
//declaration of
variables
int
factorial, number;
//Initialization
of the variables
Page
53
CS201
Introduction to Programming
factorial =
1;
number =
1;
// Prompt
the user to enter upper limit of
integers
cout <<
"Please enter the number
for factorial " ;
cin >>
number;
// using the while
loop to find out the
factorial
while(number >
1)
{
factorial =
factorial * number;
number =
number  1;
}
cout <<
"The factorial is " <<
factorial;
}
Exercise:
1) Calculate
the sum of odd integers for
a given upper limit. Also
draw flow chart of
the
program.
2) Calculate
the sum of even and
odd integers separately for
a given upper limit
using
only one loop structure.
Also draw flow chart of
the program.
Tips
·
Always
use the self explanatory variable
names
·
Practice
a lot. Practice makes a man
perfect
·
While
loop may execute zero or
more time
·
Make
sure that loop test
(condition) has an acceptable
exit.
Page
54
Table of Contents:

