ZeePedia Add to Favourites   |   Contact us


Introduction to Programming

<<< Previous Do-While Statement, for Statement, Increment/decrement Operators Next >>>
 
img
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
o
Example
o
for Statement
o
Sample Program 1
o
Increment/decrement Operators
o
Sample Program 2
o
Tips
o
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
img
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:
do
{
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
img
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
img
CS201 ­ Introduction to Programming
main ( )
{
//declare & initialize variables
int tryNum = 0 ;
char c ;
// do-while construct
do
{
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
img
CS201 ­ Introduction to Programming
// do-while construct, prompt the user to guess a number and compares it
do
{
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 :
g
Please enter a character between a-z for guessing :
z
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
img
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
as
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
img
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
img
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
img
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
img
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
img
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
x
+= 4 ;
x
-= 3 ;
x
*= 2;
x
/= 2;
x
%= 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
img
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:
5
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:
  1. What is programming
  2. System Software, Application Software, C language
  3. C language: Variables, Data Types, Arithmetic Operators, Precedence of Operators
  4. C++: Examples of Expressions, Use of Operators
  5. Flow Charting, if/else structure, Logical Operators
  6. Repetition Structure (Loop), Overflow Condition, Infinite Loop, Properties of While loop, Flow Chart
  7. Do-While Statement, for Statement, Increment/decrement Operators
  8. Switch Statement, Break Statement, Continue Statement, Rules for structured Programming/Flow Charting
  9. Functions in C: Structure of a Function, Declaration and Definition of a Function
  10. Header Files, Scope of Identifiers, Functions, Call by Value, Call by Reference
  11. Arrays: Initialization of Arrays, Copying Arrays, Linear Search
  12. Character Arrays: Arrays Comparisonm, Sorting Arrays Searching arrays, Functions arrays, Multidimensional Arrays
  13. Array Manipulation, Real World Problem and Design Recipe
  14. Pointers: Declaration of Pointers, Bubble Sort Example, Pointers and Call By Reference
  15. Introduction, Relationship between Pointers and Arrays, Pointer Expressions and Arithmetic, Pointers Comparison, Pointer, String and Arrays
  16. Multi-dimensional Arrays, Pointers to Pointers, Command-line Arguments
  17. String Handling, String Manipulation Functions, Character Handling Functions, String Conversion Functions
  18. Files: Text File Handling, Output File Handling
  19. Sequential Access Files, Random Access Files, Setting the Position in a File, seekg() and tellg() Functions
  20. Structures, Declaration of a Structure, Initializing Structures, Functions and structures, Arrays of structures, sizeof operator
  21. Bit Manipulation Operators, AND Operator, OR Operator, Exclusive OR Operator, NOT Operator Bit Flags Masking Unsigned Integers
  22. Bitwise Manipulation and Assignment Operator, Programming Constructs
  23. Pre-processor, include directive, define directive, Other Preprocessor Directives, Macros
  24. Dynamic Memory Allocation, calloc, malloc, realloc Function, Dangling Pointers
  25. History of C/C++, Structured Programming, Default Function Arguments
  26. Classes and Objects, Structure of a class, Constructor
  27. Classes And Objects, Types of Constructors, Utility Functions, Destructors
  28. Memory Allocation in C++, Operator and Classes, Structures, Function in C++,
  29. Declaration of Friend Functions, Friend Classes
  30. Difference Between References and Pointers, Dangling References
  31. Operator Overloading, Non-member Operator Functions
  32. Overloading Minus Operator, Operators with Date Class, Unary Operators
  33. Assignment Operator, Self Assignmentm, Pointer, Conversions
  34. Dynamic Arrays of Objects, Overloading new and delete Operators
  35. Source and Destination of streams, Formatted Input and Output, Buffered Input/Output
  36. Stream Manipulations, Manipulators, Non Parameterized Manipulators, Formatting Manipulation
  37. Overloading Insertion and Extraction Operators
  38. User Defined Manipulator, Static keyword, Static Objects
  39. Pointers, References, Call by Value, Call by Reference, Dynamic Memory Allocation
  40. Advantages of Objects as Class Members, Structures as Class Members
  41. Overloading Template Functions, Template Functions and Objects
  42. Class Templates and Nontype Parameters, Templates and Static Members
  43. Matrices, Design Recipe, Problem Analysis, Design Issues and Class Interface
  44. Matrix Constructor, Matrix Class, Utility Functions of Matrix, Input, Transpose Function
  45. Operator Functions: Assignment, Addition, Plus-equal, Overloaded Plus, Minus, Multiplication, Insertion and Extraction