Do-While Statement, for Statement, Increment/decrement Operators

<< Repetition Structure (Loop), Overflow Condition, Infinite Loop, Properties of While loop, Flow Chart

Switch Statement, Break Statement, Continue Statement, Rules for structured Programming/Flow Charting >>

CS201 Introduction to Programming

Lecture Handout

Introduction to programming

Lecture No. 7

Reading Material

Deitel & Deitel C++ How to Program

Chapter 2

2.11, 2.12, 2.14, 2.15, 2.17

Summary

Do-While Statement

Example

for Statement

Sample Program 1

Increment/decrement Operators

Sample Program 2

Tips

Do-While Statement

We have seen that there may be certain situations when the body of while loop does not

execute even a single time. This occurs when the condition in while is false. In while

loop, the condition is tested first and the statements in the body are executed only when

this condition is true. If the condition is false, then the control goes directly to the

statement after the closed brace of the while loop. So we can say that in while structure,

the loop can execute zero or more times. There may be situations where we may need

that some task must be performed at least once.

For example, a computer program has a character stored from a-z. It gives to user

five chances or tries to guess the character. In this case, the task of guessing the character

Page 55

CS201 Introduction to Programming

must be performed at least once. To ensure that a block of statements is executed at least

once, C provides a do-while structure. The syntax of do-while structure is as under:

{

statement(s);

}

while ( condition ) ;

Here we see that the condition is tested after executing the statements of the loop body.

Thus, the loop body is executed at least once and then the condition in do while statement

is tested. If it is true, the execution of the loop body is repeated. In case, it proves

otherwise (i.e. false), then the control goes to the statement next to the do while

statement. This structure describes `execute the statements enclosed in braces in do

clause' when the condition in while clause is true.

Broadly speaking, in while loop, the condition is tested at the beginning of the loop

before the body of the loop is performed. Whereas in do-while loop, the condition is

tested after the loop body is performed.

Therefore, in do-while loop, the body of the loop is executed at least once.

The flow chart of do-while structure is as follow:

Example

Let's consider the example of guessing a character. We have a character in the program

to be guessed by the user. Let's call it `z'. The program allows five tries (chances) to the

user to guess the character. We declare a variable tryNum to store the number of tries.

The program prompts the user to enter a character for guessing. We store this character in

a variable c.

Page 56

CS201 Introduction to Programming

We declare the variable c of type char. The data type char is used to store a single

character. We assign a character to a variable of char type by putting the character in

single quotes. Thus the assignment statement to assign a value to a char variable will be

as c = `a'. Note that there should be a single character in single quotes. The statement like

c = `gh' will be a syntax error.

Here we use the do-while construct. In the do clause we prompt the user to enter a

character.

After getting character in variable c from user, we compare it with our character i.e `z'.

We use if\else structure for this comparison. If the character is the same as ours then we

display a message to congratulate the user else we add 1 to tryNum variable. And then in

while clause, we test the condition whether tryNum is less than or equal to 5 (tryNum <=

5). If this condition is true, then the body of the do clause is repeated again. We do this

only when the condition (tryNum <= 5) remains true. If it is otherwise, the control goes

to the first statement after the do-while loop.

If guess is matched in first or second try, then we should exit the loop. We know that the

loop is terminated when the condition tryNum <= 5 becomes false, so we assign a value

which is greater than 5 to tryNum after displaying the message. Now the condition in the

while statement is checked. It proves false (as tryNum is greater than 5). So the control

goes out of the loop. First look here the flow chart for the program.

The code of the program is given below.

//This program allows the user to guess a character from a to z

//do-while construct is used to allow five tries for guessing

# include <iostream.h>

Page 57

CS201 Introduction to Programming

main ( )

{

//declare & initialize variables

int tryNum = 0 ;

char c ;

// do-while construct

{

cout << "Please enter a character between a-z for guessing :

cin >> c ;

//check the entered character for equality

if ( c == `z')

{

cout << "Congratulations, Your guess is correct" ;

tryNum = 6;

}

else

{

tryNum = tryNum + 1;

}

while ( tryNum <= 5);

}

There is an elegant way to exit the loop when the correct number is guessed. We change

the condition in while statement to a compound condition. This condition will check

whether the number of tries is less than or equal to 5 and the variable c is not equal to `z'.

So we will write the while clause as while (tryNum <= 5 && c != `z' ); Thus when a

single condition in this compound condition becomes false, then the control will exit the

loop. Thus we need not to assign a value greater than 5 to variable tryNum. Thus the

code of the program will be as:

//This program allows the user to guess a character from a to z

//do-while construct is used to allow five tries for guessing

# include <iostream.h>

main ( )

{

//declare & initialize variables

int tryNum = 0 ;

char c ;

Page 58

CS201 Introduction to Programming

// do-while construct, prompt the user to guess a number and compares it

{

cout << "Please enter a character between a-z for guessing :

cin >> c ;

//check the entered character for equality

if ( c == `z')

{

cout << "Congratulations, Your guess is correct" ;

}

else

{

tryNum = tryNum + 1;

}

while ( tryNum <= 5 && c != `z' );

}

The output of the program is given below.

Please enter a character between a-z for guessing :

Congratulations, Your guess is correct

for Loop

Let's see what we do in a loop. In a loop, we initialize variable(s) at first. Then we set a

condition for the continuation/termination of the loop. To meet the condition to terminate

the loop, we affect the condition in the body of the loop. If there is a variable in the

condition, the value of that variable is changed within the body of the loop. If the value of

the variable is not changed, then the condition of termination of the loop will not meet

and loop will become an infinite one. So there are three things in a loop structure i.e. (i)

initialization, (ii) a continuation/termination condition and (iii) changing the value of the

condition variable, usually the increment of the variable value.

To implement these things, C provides a loop structure known as for loop. This is the

most often used structure to perform repetition tasks for a known number of repetitions.

The syntax of for loop is given below.

for ( initialization condition ; continuation condition ; incrementing condition )

{

statement(s) ;

}

Page 59

CS201 Introduction to Programming

We see that a 'for statement' consists of three parts. In initialization condition, we

initialize some variable while in continuation condition, we set a condition for the

continuation of the loop. In third part, we increment the value of the variable for which

the termination condition is set.

Let's suppose, we have a variable counter of type int. We write for loop in our program

for ( counter = 0 ; counter < 10 ; counter = counter +1 )

{

cout << counter << endl;

}

This 'for loop' will print on the screen 0, 1, 2 .... 9 on separate lines (as we use endl in our

cout statement). In for loop, at first, we initialize the variable counter to 0. And in the

termination condition, we write counter < 10. This means that the loop will continue till

value of counter is less than 10. In other words, the loop will terminate when the value of

counter is equal to or greater than 10. In the third part of for statement, we write counter

= counter + 1 this means that we add 1 to the existing value of counter. We call it

incrementing the variable.

Now let's see how this loop executes. When the control goes to for statement first time, it

sets the value of variable counter to 0, tests the condition (i.e. counter < 10). If it is true,

then executes the body of the loop. In this case, it displays the value of counter which is 0

for the first execution. Then it runs the incrementing statement (i.e. counter = counter + 1

). Thus the value of counter becomes 1. Now, the control goes to for statement and tests

the condition of continuation. If it is true, then the body of the loop is again executed

which displays 1 on the screen. The increment statement is again executed and control

goes to for statement. The same tasks are repeated. When the value of counter becomes

10, the condition counter < 10 becomes false. Then the loop is terminated and control

goes out of for loop.

The point to be noted is that, the increment statement (third part of for statement) is

executed after executing the body of the loop. Thus for structure is equivalent to a while

structure, in which, we write explicit statement to change (increment/decrement) the

value of the condition variable after the last statement of the body. The for loop does this

itself according to the increment statement in the for structure. There may be a situation

where the body of for loop, like while loop, may not be executed even a single time. This

may happen if the initialization value of the variable makes the condition false. The

statement in the following for loop will not be executed even a single time as during first

checking, the condition becomes false. So the loop terminates without executing the body

of the loop.

for ( counter = 5 ; counter < 5 ; counter ++)

{

cout << "The value of counter is " << counter ;

}

Page 60

CS201 Introduction to Programming

Sample Program 1

Let's take an example to explain for loop. We want to write a program that prints the

table of 2 on the screen.

In this program, we declare a variable counter of type int. We use this variable to

multiply it by 2 with values 1 to 10. For writing the table of 2, we multiply 2 by 1, 2, 3 ..

upto 10 respectively and each time display the result on screen. So we use for loop to

perform the repeated multiplication.

Following is the code of the program that prints the table of 2.

//This program display the table of 2 up to multiplier 10

# include <iostream.h>

main ( )

{

int counter;

//the for loop

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

{

cout << "2 x " << counter << " = " << 2 * counter << "\n" ;

}

This is a simple program. In the for statement, we initialize the variable counter to 1 as

we want the multiplication of 2 starting from 1. In the condition clause, we set the

condition counter <= 10 as we want to repeat the loop for 10 times. And in the

incrementing clause, we increment the variable counter by 1.

In the body of the for loop, we write a single statement with cout. This single statement

involves different tasks. The portion `<< "2 x "' displays the string "2 x " on the screen.

After this, the next part `<< counter' will print the value of counter. The `<< " = "' will

display ` = ` and then the next part `<< 2 * counter' will display the result of 2 multiply

by counter and the last <<"\n" ( the new line character) will start a new line. Thus in the

first iteration where the value of counter is 1, the cout statement will display the

following line

2x1=2

After the execution of cout statement, the for statement will increment the counter

variable by 1. Thus value of counter will be 2. Then condition will be checked which is

still true. Thus the body of for loop (here the cout statement) will be executed again

having the value of counter 2. So the following line will be printed.

2x2=4

Page 61

CS201 Introduction to Programming

The same action will be repeated 10 times with values of counter from 1 to 10. When the

value of counter is 11, the condition ( counter <= 10 ) will become false and the loop

will terminate.

The output of the above program is as the following.

2x1=2

2x2=4

2x3=6

2x4=8

2 x 5 = 10

2 x 6 = 12

2 x 7 = 14

2 x 8 = 16

2 x 9 = 18

2 x 10 = 20

Now what will we do, if some one says us to write a table of 3, or 4 or 8 or any other

number. Here comes the point of re-usability and that a program should be generic. We

write a program in which a variable is used instead of a hard code number. We prompt

the user to enter the number for which he wants a table. We store this number in the

variable and then use it to write a table. So in our previous example, we now use a

variable say number where we were using 2. We also can allow the user to enter the

number of multipliers up to which he wants a table. For this, we use a variable

maxMultiplier and execute the loop for maxMultiplier times by putting the condition

counter <= maxMultiplier. Thus our program becomes generic which can display a table

for any number and up to any multiplier.

Thus, the code of our program will be as below:

//This program takes an integer input from user and displays its table

//The table is displayed up to the multiplier entered by the user

# include <iostream.h>

main ( )

{

int counter, number, maxMultiplier ;

// Prompt the user for input

cout << "Please enter the number for which you want a table : " ;

cin >> number ;

cout << "Please enter the multiplier up to which you want a table : " ;

cin >> maxMultiplier ;

Page 62

CS201 Introduction to Programming

//the for loop

for ( counter = 1 ; counter <= maxMultiplier ; counter = counter + 1)

{

cout << number << " x " << counter << " = " << number * counter << "\n" ;

}

The output of the program is shown as follows:

Please enter the number for which you want a table : 7

Please enter the multiplier up to which you want a table : 8

7x1=7

7 x 2 = 14

7 x 3 = 21

7 x 4 = 28

7 x 5 = 35

7 x 6 = 42

7 x 7 = 49

7 x 8 = 56

Here is a guideline for programming style. We should avoid using constant values in our

calculations or in long routines. The disadvantage of this is that if we want to change that

constant value later, then we have to change every occurrence of that value in the

program. Thus we have to do a lot of work and there may be some places in code where

we do not change that value. To avoid such situations, we can use a variable at the start

and assign that constant value to it and then in the program use that variable. Thus, if we

need to change the constant value, we can assign the new value to that variable and the

remaining code will remain the same. So in our program where we wrote the table of 2,

we can use a variable (say number) and assign it the value 2. And in cout statement we

use this variable instead of constant 2. If we want that the program should display a table

of 5, then we just change the value of the variable. So for good programming, use

variables for constant values instead of explicit constant values.

Increment Decrement Operators

We have seen that in while, do-while and for loop we write a statement to increase the

value of a variable. For example, we used the statements like counter = counter + 1;

which adds 1 to the variable counter. This increment statement is so common that it is

used almost in every repetition structure (i.e. in while, do-while and for loop). The C

Page 63

CS201 Introduction to Programming

language provides a unary operator that increases the value of its operator by 1. This

operator is called increment operator and sign ++ is used for this. The statement counter

= counter + 1; can be replaced with the statement

counter ++ ;

The statement counter++ adds 1 to the variable counter. Similarly the expressions i = i +

1 ; and j = j + 1 ; are equivalent to i++ ; and j++; respectively. There is also an operator

-- called decrement operator. This operator decrements, the value of its operand by 1. So

the statements counter = counter - 1; and j = j - 1; are equivalent to counter--; and j--;

respectively.

The increment operator is further categorized as pre-increment and post-increment.

Similarly, the decrement operator, as pre-decrement and post-decrement.

In pre-increment, we write the sign before the operand like ++j while in post-increment,

the sign ++ is used after the operand like j++. If we are using only variable increment,

pre or post increment does not matter. In this case, j++ is equivalent to ++j. The

difference of pre and post increment matters when the variable is used in an expression

where it is evaluated to assign a value to another variable. If we use pre-increment ( ++j ),

the value of j is first increased by 1. This new value is used in the expression. If we use

post increment ( j++ ),the value of j is used in the expression. After that it is increased by

1. Same is the case in pre and post decrement.

If j = 5, and we write the expression

x = ++ j ;

After the evaluation of this expression, the value of x will be 6 (as j is incremented first

and then is assigned to x). The value of j will also be 6 as ++ operator increments it by 1.

If j = 5, and we write the expression

x = j++ ;

Then after the evaluation of the expression, the value of x will be 5 (as the value of j is

used before increment) and the value of j will be 6.

The same phenomenon is true for the decrement operator with the difference that it

decreases the value by 1. The increment and decrement operators affect the variable and

update it to the new incremented or decremented value.

The operators ++ and -- are used to increment or decrement the variable by 1. There may

be cases when we are incrementing or decrementing the value of a variable by a number

other than 1. For example, we write counter = counter + 5; or j = j 4;. Such

assignments are very common in loops, so C provides operators to perform this task in

short. These operators do two things they perform an action (addition, subtraction etc)

and do some assignment.

These operators are +=, -=, *=, /= and %=. These operators are compound assignment

operators. These operators assign a value to the left hand variable after performing an

action (i.e. +, -, *, / and %). The use of these operators is explained by the following

examples.

Page 64

CS201 Introduction to Programming

Let's say we have an expression, counter = counter + 5;. The equivalent of this

expression is counter += 5;. The statement counter += 5; does two tasks. At first, it adds

5 to the value of counter and then assigns this result to counter. Similarly the following

expressions

x=x+4;

x=x-3;

x=x*2;

x =x /2;

x = x % 3;

can be written in equivalent short statements using the operators ( +=, -=, *=, /=, %= ) as

follows

+= 4 ;

-= 3 ;

*= 2;

/= 2;

%= 3 ;

Note that there is no space between these operators. These are treated as single signs. Be

careful about the operator %=. This operator assigns the remainder to the variable. These

operators are alternate in short hand for an assignment statement. The use of these

operators is not necessary. A programmer may use these or not. It is a matter of style.

Example Program 2

Let's write a program using for loop to find the sum of the squares of the integers from 1

to n. Where n is a positive value entered by the user (i.e. Sum = 12 + 22 + 32 + ......+ n2)

The code of the program is given below:

//This program displays the sum of squares of integers from 1 to n

# include <iostream.h>

main ( )

{

//declare and initialize variables

int i, n, sum;

sum = 0 ;

//get input from user and construct a for loop

cout << "Please enter a positive number for sum of squares:

cin >> n;

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

Page 65

CS201 Introduction to Programming

{

sum += i * i ;

}

cout << "The sum of the first " << n << " squares is " << sum << endl ;

}

In the program declared three variables i, n and sum. We prompted the user to enter a

positive number. We stored this number in the variable n. Then we wrote a for loop. In

the initialization part, we initialized variable i with value 1 to start the counting from 1. In

the condition statement we set the condition i less than or equal to n (number entered by

the user) as we want to execute the loop n times. In the increment statement, we

incremented the counter variable by 1. In the body of the for loop we wrote a single

statement sum += i * i ;. This statement takes the square of the counter variable ( i )and

adds it to the variable sum. This statement is equivalent to the statement sum = sum + ( i

* i ) ; Thus in each iteration the square of the counter variable (which is increased by 1 in

each iteration ) is added to the sum. Thus loop runs n times and the squares of numbers

from 1 to n are summed up. After completing the for loop the cout statement is executed

which displays the sum of the squares of number from 1 to n.

Following is the output when the number 5 is entered.

Please enter a positive number for sum of squares:

The sum of the first 5 squares is 55

Tips

· Comments should be meaningful, explaining the task

Don't forget to affect the value of loop variable in while and do-while

loops

Make sure that the loop is not an infinite loop

Don't affect the value of loop variable in the body of for loop, the for loop

does this by itself in the for statement

Use pre and post increment/decrement operators cautiously in expressions

Page 66

Table of Contents: