Control Structures in
C++
while, do/while, for
Repetition: An Introduction
• You can repeat many steps in an algorithm.
• Repetition of a sequence of steps in an algorithm is called
a loop.
• Types of loops:
• - Counter-controlled loops
• (e.g. WHILE, FOR, DO..WHILE)
• - Conditional loops (e.g. WHILE., DO..WHILE)
Example
int sum ;
sum = 1+2+3+4+5+……..+10 ;
cout << sum ;
Find the Sum of the first 100 Integer
starting from 1
The while Loop
• The general form of the while statement is:
• while(expression)
• statement
• while is a reserved word
• Statement can be simple or compound
• Expression acts as a decision maker and is usually
a logical expression
• Statement is called the body of the loop
• The parentheses are part of the syntax
The while Loop (continued)
• Expression provides an entry condition
• Statement executes if the expression initially
evaluates to true
• Loop condition is then reevaluated
• Statement continues to execute until the
expression is no longer true
while Looping (Repetition)
Structure (continued)
• Infinite loop: continues to execute endlessly
– Avoided by including statements in loop body
that assure exit condition is eventually false
while Looping (Repetition)
Structure (continued)
Designing while Loops
Case 1: Counter-Controlled while
Loops
• If you know exactly how many pieces of
data need to be read, the while loop
becomes a counter-controlled loop
The while Loop (continued)
• Infinite loop: continues to execute endlessly
• Can be avoided by including statements in the
loop body that assure exit condition will
eventually be false
Counter-Controlled while Loops
• If you know exactly how many pieces of data need to be read, the
while loop becomes a counter-controlled loop
• The syntax is:
• counter = 0;
• while(counter < N)
• {
• .
• counter++;
• .
• }
• Suppose the input is: 8 9 2 3 90 38 56 8 23 89 7 2 Suppose
you want to add these numbers and find their average.
Consider the following program:
• Suppose the input is: 8 9 2 3 90 38 56 8 23 89 7 2 Suppose you want to
add these numbers and find their average. Consider the following
program:
Sentinel-Controlled while Loops
• Sentinel variable is tested in the condition and loop ends
when sentinel is encountered
• The syntax is:
• cin>>variable;
• while(variable != sentinel)
• {
• .
• cin>> variable;
• .
• }
Case 2: Sentinel-Controlled
while Loops
• Sentinel variable is tested in the condition
and loop ends when sentinel is encountered
• Telephone Digits The following program reads the letter
codes A to Z and prints the corresponding telephone digit.
This program uses a sentinel-controlled while loop. To stop
the program, the user is prompted for the sentinel, which is
#. This is also an example of a nested control structure, in
which if...else, switch, and the while loop are nested.
The while Repetition Structure
• Repetition structure
– Programmer specifies an action to be repeated while some
condition remains true
– Psuedocode
• while there are more items on my shopping list
• Purchase next item and cross it off my list
– while loop repeated until condition becomes false.
• Example
– int product = 2;
– while ( product <= 1000 )
– product = 2 * product;
The while Repetition Structure
• Flowchart of while loop
true
condition statement
false
int x = 2;
while (x >= 0){
if ( x == 2){
cout << “Value of x is : “ << x << endl;
}
x = x – 1;
}
Formulating Algorithms
(Counter-Controlled Repetition)
• Counter-controlled repetition
– Loop repeated until counter reaches a certain
value.
• Definite repetition
– Number of repetitions is known
• Example
– A class of ten students took a quiz. The
grades (integers in the range 0 to 100) for this
quiz are available to you. Determine the class
average on the quiz.
Formulating Algorithms
(Counter-Controlled Repetition)
• Pseudocode for example:
• Set total and grade counter to zero
• While grade counter <= 10
Input the next grade
Add the grade into the total
grade counter++
• average = total divided / 10
• Print the class average
• Following is the C++ code for this example
1 // Fig. 2.7: fig02_07.cpp
2 // Class average program with counter-controlled repetition
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 int main()
10 {
11 int total, // sum of grades
12 gradeCounter, // number of grades entered
13 grade, // one grade
14 average; // average of grades
15
16 // initialization phase
17 total = 0; // clear total
18 gradeCounter = 1; // prepare to loop
19 The counter gets incremented each
20 // processing phase time the loop executes. Eventually, the
21 while ( gradeCounter <= 10 ) { // loop 10 counter
times causes the loop to end.
22 cout << "Enter grade: "; // prompt for input
23 cin >> grade; // input grade
24 total = total + grade; // add grade to total
25 gradeCounter = gradeCounter + 1; // increment counter
26 }
27
28 // termination phase
29 average = total / 10; // integer division
30 cout << "Class average is " << average << endl;
31
32 return 0; // indicate program ended successfully
33 }
Enter grade: 98
Enter grade: 76
Enter grade: 71
Enter grade: 87
Enter grade: 83
Enter grade: 90
Enter grade: 57
Enter grade: 79
Enter grade: 82
Enter grade: 94
Class average is 81
Program Output
Assignment Operators
• Assignment expression abbreviations
• c = c + 3; can be abbreviated as c += 3; using the
addition assignment operator
• Statements of the form
• variable = variable operator expression;
– can be rewritten as
• variable operator= expression;
• Examples of other assignment operators
include:
– d -= 4 (d = d - 4)
Increment and Decrement
Operators
• Increment operator (c++) - can be used
instead of
• c += 1
• Decrement operator (c--) - can be used
instead of
• c -= 1
• Preincrement
• When the operator is used before the variable (++c
or –c)
• If c = 5, then
– cout << ++c; prints out 6 (c is changed before
cout is executed)
– cout << c++; prints out 5 (cout is executed
before the increment. c now has the value of 6)
• When Variable is not in an expression
– Preincrementing and postincrementing have the
same effect.
• ++c;
• cout << c;
– and
• c++;
• cout << c;
– have the same effect.
Essentials of Counter-Controlled
Repetition
• Counter-controlled repetition requires:
– The name of a control variable (or loop
counter).
– The initial value of the control variable.
– The condition that tests for the final value of
the control variable (i.e., whether looping
should continue).
– The increment (or decrement) by which the
control variable is modified each time through
the loop.
• Example:
• int counter =1; //initialization
• while (counter <= 10){ //repetitio
• // condition
• cout << counter << endl;
• ++counter; //increment
– }
Write a program that calculates the
factorial of a given number using a while
loop.
• #include <iostream>
• using namespace std;
• int main()
• {
• int num,
• factorial = 1;
• cout << "Enter a number: "; cin >> num; int i = num;
• while (i > 1)
• {
• factorial *= i; // Multiply factorial by current value of i i--; //
Decrement i
• }
• cout << "Factorial of " << num << " is: " << factorial << endl;
• return 0;
• }
Write a program that counts the number of digits
in a given integer using a while loop.
• #include <iostream>
• using namespace std;
• int main() {
• int num, count = 0;
• cout << "Enter a number: ";
• cin >> num;
• if (num == 0) count = 1; // Special case for zero
• while (num > 0) {
• num /= 10; // Remove last digit
• count++; // Increase count
• }
• cout << "Number of digits: " << count << endl;
• return 0;
• }
The for Repetition Structure
• The general format when using for loops is
– for ( initialization; LoopContinuationTest;
increment )
– statement
• Example:
– for( int counter = 1; counter <= 10; counter++ )
• cout << counter << endl;
– Prints the integers from one to ten
• For loops can usually be rewritten as while
loops:
• initialization;
• while ( loopContinuationTest){
• statement
• increment;
•}
• Initialization and increment as comma-
separated lists
• for (int i = 0, j = 0; j + i <= 10; j++, i++)
• cout << j + i << endl;
Flowchart for for
Initialize variable
Condition true statement
Test the variable Increment variable
false
• Program to sum the even numbers from 2 to 100
1 // Fig. 2.20: fig02_20.cpp
2 // Summation with for
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 int main()
9 {
10 int sum = 0;
11
12 for ( int number = 2; number <= 100; number += 2 )
13 sum += number;
14
15 cout << "Sum is " << sum << endl;
16
17 return 0;
18 }
Write a program that prints a right-angled
triangle of stars using a for loop.
Enter the number of rows: 5
*
**
***
****
*****
• #include <iostream>
• using namespace std;
• int main() {
• int rows;
• cout << "Enter the number of rows: ";
• cin >> rows;
• for (int i = 1; i <= rows; i++) {
• for (int j = 1; j <= i; j++) {
• cout << "* ";
• }
• cout << endl;
• }
• return 0;
• }
1 // Fig. 2.22: fig02_22.cpp
2 // Counting letter grades
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 int main()
10 {
11 int grade, // one grade
12 aCount = 0, // number of A's
13 bCount = 0, // number of B's
14 cCount = 0, // number of C's
15 dCount = 0, // number of D's
16 fCount = 0; // number of F's
17
18 cout << "Enter the letter grades." << endl
19 << "Enter the EOF character to end input." << endl;
20
21 while ( ( grade = [Link]() ) != EOF ) {
22 Notice how the case statement is used
23 switch ( grade ) { // switch nested in while
24
25 case 'A': // grade was uppercase A
26 case 'a': // or lowercase a
27 ++aCount;
28 break; // necessary to exit switch
29
30 case 'B': // grade was uppercase B
31 case 'b': // or lowercase b
32 ++bCount;
33 break;
34
35 case 'C': // grade was uppercase C
36 case 'c': // or lowercase c
37 ++cCount;
38 break;
39
40 case 'D': // grade was uppercase D
break causes switch to end and
41 case 'd': // or lowercase d
42 ++dCount; the program continues with the first
43 break; statement after the switch
44 structure.
45 case 'F': // grade was uppercase F
46 case 'f': // or lowercase f
47 ++fCount;
48 break;
49
50 case '\n': // ignore newlines,
51 case '\t': // tabs,
52 Notice
case ' ': // and spaces in input the default statement.
53 break;
54
55 default: // catch all other characters
56 cout << "Incorrect letter grade entered."
57 << " Enter a new grade." << endl;
58 break; // optional
59 }
60 }
61
62 cout << "\n\nTotals for each letter grade are:"
63 << "\nA: " << aCount
64 << "\nB: " << bCount
65 << "\nC: " << cCount
66 << "\nD: " << dCount
67 << "\nF: " << fCount << endl;
68
69 return 0;
70 }
Enter the letter grades.
Enter the EOF character to end input.
a
B
c
C
A
d
f
C
E
Incorrect letter grade entered. Enter a new grade.
D
A
b
Totals for each letter grade are:
A: 3
B: 2
C: 3
Program Output
D: 2
F: 1
The do/while Repetition
Structure
• The do/while repetition structure is similar
to the while structure,
– Condition for repetition tested after the body of
statement
the loop is executed
• Format:
true
• do { condition
• statement false
• } while ( condition );
• Example (letting counter = 1):
• do {
The break and continue
Statements
• Break
– Causes immediate exit from a while, for,
do/while or switch structure
– Program execution continues with the first
statement after the structure
– Common uses of the break statement:
• Escape early from a loop
• Skip the remainder of a switch structure
• Continue
– Skips the remaining statements in the body of a
while, for or do/while structure and proceeds
with the next iteration of the loop
– In while and do/while, the loop-continuation
test is evaluated immediately after the continue
statement is executed
– In the for structure, the increment expression is
executed, then the loop-continuation test is
evaluated
The continue Statement
• Causes an immediate jump to the loop test
• int next = 0;
• while (true){
– cin >> next;
– if (next < 0)
• break;
– if (next % 2) //odd number, don’t print
• continue;
– cout << next << endl;
Sentinel-Controlled Repetition
• Suppose the previous problem becomes:
– Develop a class-averaging program that will
process an arbitrary number of grades each time
the program is run.
– Unknown number of students - how will the
program know to end?
• Sentinel value
– Indicates “end of data entry”
• Top-down, stepwise refinement
– begin with a pseudocode representation of the
top:
– Determine the class average for the quiz
– Divide top into smaller tasks and list them in
order:
– Initialize variables
– Input, sum and count the quiz grades
– Calculate and print the class average
• Input, sum and count the quiz grades
» to
• Input the first grade (possibly the sentinel)
• While the user has not as yet entered the sentinel
• Add this grade into the running total
• Add one to the grade counter
• Input the next grade (possibly the sentinel)
• Refine
• Calculate and print the class average
» to
1 // Fig. 2.9: fig02_09.cpp
2 // Class average program with sentinel-controlled repetition.
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8 using std::ios;
9
10 #include <iomanip>
11
12 using std::setprecision;
13 using std::setiosflags;
14
15 int main()
Data type double used to represent
16 {
decimal numbers.
17 int total, // sum of grades
18 gradeCounter, // number of grades entered
19 grade; // one grade
20 double average; // number with decimal point for average
21
22 // initialization phase
23 total = 0;
24 gradeCounter = 0;
25
26 // processing phase
27 cout << "Enter grade, -1 to end: ";
28 cin >> grade;
29
30 while ( grade != -1 ) {
31 total = total + grade;
32 gradeCounter = gradeCounter + 1;
33 cout << "Enter grade, -1 to end: ";
34 cin >> grade;
35 }
36
37 // termination phase
38 if ( gradeCounter != 0 ) {
39 average = static_cast< double >( total ) / gradeCounter;
40 cout << "Class average is " << setprecision( 2 )
41 << setiosflags( ios::fixed | ios::showpoint )
42 << average << endl;
43 }
44 else
static_cast<double>() - treats total as a
45 cout << "No grades were entered" << endl;
46 double temporarily.
47 return 0; // indicate program ended successfully
48 }Required because dividing two integers truncates the
remainder.
Enter grade, -1 to end:
gradeCounter is an75int, but it gets promoted tosetprecision(2) - prints only two digits
Enter grade, -1 to end: 94
double.
Enter grade, -1 to end: 97 past decimal point.
Enter grade, -1 to end: 88
Enter grade, -1 to end: 70
Enter grade, -1 to end: 64
Programs that use this must include <iomanip>
Enter grade, -1 to end: 83
Enter grade, -1 to end: 89
Enter grade, -1 to end: -1
Class average is 82.50
Nested control structures
• Problem:
– A college has a list of test results (1 = pass, 2
= fail) for 10 students. Write a program that
analyzes the results. If more than 8 students
pass, print "Raise Tuition".
• We can see that
– The program must process 10 test results. A
counter-controlled loop will be used.
– Two counters can be used—one to count the
number of students who passed the exam and
Nested control structures
• High level description of the algorithm
• Initialize variables
• Input the ten quiz grades and count
passes and failur
• Print a summary of the exam results
and decide if
• tuition should be raised
1 // Fig. 2.11: fig02_11.cpp
2 // Analysis of examination results
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 int main()
10 {
11 // initialize variables in declarations
12 int passes = 0, // number of passes
13 failures = 0, // number of failures
14 studentCounter = 1, // student counter
15 result; // one exam result
16
17 // process 10 students; counter-controlled loop
18 while ( studentCounter <= 10 ) {
19 cout << "Enter result (1=pass,2=fail): ";
20 cin >> result;
21
22 if ( result == 1 ) // if/else nested in while
23 passes = passes + 1;
24 else
25 failures = failures + 1;
26
27 studentCounter = studentCounter + 1;
28 }
29
30 // termination phase
31 cout << "Passed " << passes << endl;
32 cout << "Failed " << failures << endl;
33
34 if ( passes > 8 )
35 cout << "Raise tuition " << endl;
36
37 return 0; // successful termination
38 }
3. Print results
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 2
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Enter result (1=pass,2=fail): 1
Passed 9
Failed 1
Raise tuition
• // Fig. 2.21: fig02_21.cpp
• // Calculating compound interest
• #include <iostream>
• using std::cout;
• using std::endl;
• using std::ios;
• int main()
• {
• double amount, // amount on
deposit
• principal = 1000.0, // starting
principal
• rate = .05; // interest rate