CHAPTER EIGHT: C Programming:- Decision Making and Looping

Chapter Objectives
By the end of this chapter the learner should be able to
Describe and use appropriately the C decision making and Looping control structures
 The while statement
 The do statement
 The for statement
 Nesting for statements
Describe and use appropriately syntax to jumping in and jumping out of a Loop.
 Break statement

8.1 Introduction
The looping capabilities in C enables us to develop concise programs containing repetitive processes
without the use of GOTO statements. In looping the sequence of statements are executed until some
conditions for termination of the loop is satisfied. A program loop consists of two segments, one known
as the body of the loop and the other as the control statement. The control statement test certain
conditions and then directs the repeated execution of the statement contained in the body of loop.

8.2. Classification of Loop Control Structures;

Depending on the position of the control statement in the loop a control structure may be classified as
either a Entry-controlled loop(Pre-test) or an Exit-controlled loop (Post-test), Fig 8.1. In the entry
controlled loop, the control conditions are tested before the start of the loop execution, while in the Exit-
controlled loop the control conditions are tested before the end of the loop execution, thus the body of
loop is executed unconditionally for the first time

False Body of the loop

Test
Condition

True

Body of the loop Test False

Condition

True
 (a) Entry controlled loop flow chart (b) Exit controlled loop flow chart

Fig 8.1 Loop control structures

The test-condition should be carefully stated in order to perform the desired number of loop executions.
A looping process in general would include the following four steps;
 Setting an initialization of a condition variable.
 Execution of the statements in the loop.
 Test for a specified value of the condition variable for execution of the loop.
 Incrementing or updating the condition variable.

The test may be either to determine whether the loop has been repeated the specified number of times or
to determine whether a particular condition has been met.
The C language provides for three constructs for performing loop operations;
 The while statement
 The do statement
 The for statement

Based on the nature of control variable and the kind of value assigned to it for testing the control
expression, the loop may be classified into two general categories;
 Counter-controlled loops: when in advance the number of time the loop is to be executed is known.
Control variable called Counter is used, which is initialized, tested and updated properly for the
desired loop operations. The number of times the loop is to be executed may be a constant or a
variable that is assigned a value. It is also called definite repetition loop.
 Sentinel-controlled loops: a special value is used to change the loop control expression from true to
false. The number of repetitions are not known before the loop begins executing and is thus called
indefinite repetition loop.

8.3. The While Statement

The simplest of all the looping structures in C. The while statement take the following form;
while (test condition)
{
body of loop
 }

The while is an entry-controlled loop statement. The test-condition is evaluated and if true the body of the
loop is executed. After the execution the test-condition is evaluated again and if true the body of the loop
is executed again. This process is repeated until the test-condition finally becomes false and the control is
transferred outside the loop where the program continues with the statements immediately after the body
of the loop.

Program Example 8.1 Illustration of the while statement;

#include<stdio.h>
#include<conio.h>
main()
{ sum= 0;
n = 1;
while (n <= 10)
{
sum = sum + n*n;
n = n+ 1;
}
printf (“Sum = %d\n”, sum);
getch();
}

Program example 8.2. Program to compute x to the power of n using while loop
#include<stdio.h>
#include<conio.h>
main()
{
int count, n;
float x, y;
printf(“Enter the values for x and b”);
scanf(“%f %d”, &x, &n);
y =1 ;
count = 1
 while (count <= n)
{
y = y*x;
count++;
}
printf(“\nx = %f; n = %d; x to power n = %f\n”, x,n,y);
getch();
}

8.4. The Do Statement

Use when the body of the loop needs to be executed first before evaluating the test-condition.
Format
do
{
body of the loop
}
while (test-condition);

On reaching the do statement, the program proceeds to evaluate the body of the loop first, and at the end
of the loop the test-condition in the while statement is evaluated. If the test-condition is true the programs
evaluates the body of loop and these process is repeated until the test-condition is false. If the test-
condition is false the loop is terminated and the control goes to the statement that appears immediately
after the while statement.

Since the test-condition is evaluated at the bottom of the loop, the do…..while construct provides an exit–
controlled loop and thus the body of the loop is always executed at least once.

Program example 8.3. Program to print the multiplication table 1x1 to 12x12 using Nested do ..
while loops
#include<stdio.h>
#include<conio.h>
#define COLMAX 10
#define ROWMAX 12
main()
 {
int row, column, y;
row = 1;
printf(" MULTIPLICATION TABLE \n");
printf(" ----------------------------------------- \n");
do /* Outer loop begins */
{
column = 1;
do /* inner loop begins */
{
y = row * column;
printf("%4d", y);
column = column + 1;
}
while(column <= COLMAX); /*Inner loop Ends*/
printf("\n");
row = row + 1;
}
while (row <= ROWMAX); /* Outer loop Ends*/
printf (" ---------------------------------------------\n");
getch();
}
Out put

The printf in the inner loop does not contain any new (\n) , thus allowing the printing of all row values in
one line. The empty printf in the outer loop initiates a new line to print the next row.
8.5. The For Statement
The for loop is an entry-controlled loop that provides a more concise loop control structure. The general
form for the for loop is
for (initialization ; test-condition; increment)
{
body of the loop
}
The execution of the for statement is as follows;
1. Initialization of the control variables is done first using assignment statements such as i =1 and count
= 0;. The i and count are called the loop control variables.
2. The value of the control variable is tested using the test-condition. The test-condition is a relational
expression such as i<10 that determines when the loop will exit. If the condition is true, the body of
the loop is executed; otherwise the loop is terminated and the execution continues with the statement
that immediately follows the loop.
3. When the body of the loop is executed, the control is transferred back to the for statement after
evaluating the last statement in the loop. The control is incremented using an assignment statement
such as i = i + 1 and the new value of the control variable is again tested to see whether it satisfies the
loop condition. Example
#include<stdio.h>
#include<conio.h>

main()
{
int x;
for (x =0; x<=9; x= x+1)
{
printf("%d", x);
}
printf("\n");
getch();
}

In the above example, the for loop is executed 10 times and prints the digits 0 to 9.
Note the three sections in the for ( ) statement must be separated by semicolons(;). There is no (;) after
the increment section (x = x+1)

The for statement allows for negative increments, example

#include<stdio.h>
#include<conio.h>
 main()
{
int x;
for (x =9; x>=0; x= x-1)
{
printf("%d", x);
}
printf("\n");

getch();
}

Program example 8.4 Use of for loop

#include<stdio.h>
#include<conio.h>
#define ROW 10
#define COLOUMN 12
main()
{
int row,coloumn,product[ROW][COLOUMN],i,j;
printf("Multiplication table:\n\n");
printf(" ");
for(j=1;j<=COLOUMN;j++)
{
printf("%4d",j);
}
printf("\n");
printf("-----------------------\n");
for(i=0;i<ROW; i++)
{
row=i+1;
printf("%2d|",row);
for(j=1;j<=COLOUMN;j++)
{
coloumn=j;
product[i][j]=row*coloumn;
printf("%4d",product[i][j]);
 }
printf("\n");
}
getch();
}

To initialize more than one variable in the for statement

p = 1;
for (n=0; n<17; ++n)
becomes
for (p=1, n+0; n<17; ++n)

8.6. Nesting of for loops

Nesting of the for loop ie one for statement within another for statement is allowed in C. Two loops can
be nested as follows;
…
….

for (i =1; i<10; ++i)

{
**********
************
for (j =1; j !=5; ++j)
{
************** Inner Outer
*********** loop Loop
}
***************
***************
}

*************
*************

Program example 8.5. Program to print the Multiplication table using Nested for loop
#include<stdio.h>
#include<conio.h>
#define COLMAX 10
#define ROWMAX 12
main()
 {
int row, column, y;
row = 1;
printf(" MULTIPLICATION TABLE \n");
printf(" ----------------------------------------- \n");
for (row=1; row<=ROWMAX; ++row)
{
for (column = 1; column <= COLMAX; ++column)
{
y = row * column;
printf("%4d", y);
}
printf("\n");
}
printf (" ---------------------------------------------\n");
getch();
}

8.7. Selecting a Loop

 Analyse the problem and see whether it requires a pre-test or post-test loop.
 If it requires a post-test loop, then we can use the do …. While
 If it requires a pre-test loop, then use either for loop or while loop.
 Decide whether the loop termination requires counter-based control or sentinel-based control.
 Use for loop if the counter-based control is necessary
 Use while loop if the sentinel-based control is required.
 Both the counter-controlled and sentinel-controlled loops can be implemented by all the three control
structures.

8.8. Jumping out of a Loop

An early exit from a loop can be accomplished by using the break statement or the goto statement.
When break statement is encountered inside a loop, the loop is immediately exited and the program
continues with the statement immediately following the loop. When loops are nested, the break would
only exit from the loop containing it. Break only exits one loop.
do
 {
if (condition)
break;

Exit
******
From *******
loop
}
While ( …….. )
*****
Fig 8.5. Exiting a loop with break statement

The Goto statement can transfer the control to any place on a program, and thus it is useful in proving
branching in a loop. Use goto statement to exit from a deeply nested loops when an error occurs.

Example of using goto statement to jump out of a loop

while ( )
{
if (error)
goto stop;
*********
if (condition) Exit loop
goto abc;
************ jump within
********** loop
abc
*********
}
stop;
*******
*********

8.9 Structured programming

An approach to the design and development of programs. It is a discipline of making a program’s logic
easy to understand by using only the basic three control structures;
 Sequence (straight line) structures
 Selection (branching) structures
 Repetition (looping) structures.

The use of structured programming techniques helps ensure well-designed programs that are easier to
write, read, debug and maintain compared to those that are unstructured. Structured programming
discourages the implementation of unconditional branching using jump statements such as goto, break
and continue.

Chapter Review Questions

1. Write a for statement to print each of the following sequences of integer
a) 1,2,3,4,8,16,32
b) 1,3,9,27,81,243
c) -4, -2, 0, 2, 4
2. Change the following for loops to while loops
a. for (m=1; m<10; m= m+1)
printf(m);
b. for (; scanf(“%d”, &m) != -1)
printf(m);

3. Write a program to compute the sum of the digits of a given integer.