

Summary
o 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
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 45
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 46
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 47
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 48
//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 49
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 reusable
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 50
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 51
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 52
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 53
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 54
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.



