Sie sind auf Seite 1von 88

# 1

## Chapter 2 - Control Structures

Outline
2.1 Introduction
2.2 Algorithms
2.3 Pseudocode
2.4 Control Structures
2.5 The if Selection Structure
2.6 The if/else Selection Structure
2.7 The while Repetition Structure
2.8 Formulating Algorithms: Case Study 1
(Counter-Controlled Repetition)
2.9 Formulating Algorithms with Top-Down, Stepwise Refinement:
Case Study 2 (Sentinel-Controlled Repetition)
2.10 Formulating Algorithms with Top-Down, Stepwise Refinement:
Case Study 3 (Nested Control Structures)
2.11 Assignment Operators
2.12 Increment and Decrement Operators
2.13 Essentials of Counter-Controlled Repetition
2.14 The for Repetition Structure
2.15 Examples Using the for Structure

2

## Chapter 2 - Control Structures

Outline
2.16 The switch Multiple-Selection Structure
2.17 The do/while Repetition Structure
2.18 The break and continue Statements
2.19 Logical Operators
2.20 Confusing Equality (==) and Assignment (=) Operators
2.21 Structured-Programming Summary

3

2.1 Introduction

## • Before writing a program:

– Have a thorough understanding of problem
– Carefully plan your approach for solving it

## • While writing a program:

– Know what “building blocks” are available
– Use good programming principles

4

## • THERE ARE TWO BASIC ASPECTS of

programming:
– data and instructions.
• To work with data
– you need to understand variables and types
• To work with instructions
– you need to understand control structures and subroutines.
– You'll spend a large part of the course becoming familiar
with these concepts

Ref: http://math.hws.edu/javanotes/c1/s4.html

5

## A few good programming practices

• Be consistent with formatting. A well formtated piece of code
– Useint
proper spacing and indentation
main()
– There's
{ nothing worse than code that is difficult to read because it
is poorly formatted.
if ( num1 == num2 )
• Be consistent with naming conventions
– Chose onecout << style
naming num1and
<< stick
" iswith
equal
it to " << num2 << endl;

• Use global
if ( num1 != num2
variables )
sparingly
– Avoid them
cout << num1
as much << " is
as possible not equal to " << num2 << endl;
• Comment.
that describe both what formtated
A poorly the code is doing
piece and why you
of code
decided to do it one way and not another way Ref:
int main()
• Check return values for error conditions
{ if (num1==num2)
• Provide useful error messages.
cout<<num1<<" is equal to "<<num2<<endl;
• Recover (or fail) gracefully.
if (num1!=num2)
http://www.kmoser.com/articles/Good_Programming_Practic
cout<<num1<<" is not equal to " <<num2<<endl; }
es.php
6

2.2 Algorithms

## • All computing problems

– can be solved by executing a series of actions in a specific
order
• Algorithm
– A procedure determining the
• Actions to be executed
• Order in which these actions are to be executed
• Program control
– Specifies the order in which statements are to executed

7

## 1.Insert the key

2.Make sure car is in neutral gear
3.Press the gas pedal/ (Accelerator)
4.Turn the key to the start position
5.If the engine starts in 6 seconds 
1.Release the key to the ignition position
6.Else if the engine does not start in 6 seconds 
1.Release the key and gas pedal
2.Wait for 10 seconds , and repeat the steps 3 – 6, but no more
than 5 times
7. If the car does not start
1.Call the workshop 7
8

2.3 Pseudocode

• Pseudocode
– Artificial, informal language used to develop algorithms
– Similar to everyday English
– Not actually executed on computers
– Allows us to “think out” a program before writing the code
for it
– Easy to convert into a corresponding C++ program
– Consists only of executable statements

Example:
If student’s grade is greater than or equal to 60
Print "Passed“

9

## 2.4 Control Structures

• Sequential execution
– Statements executed one after the other in the order written
• Transfer of control
– When the next statement executed is not the next one in
sequence
• Bohm and Jacopini: all programs written in terms
of 3 control structures
– Sequence structure
• Built into C++. Programs executed sequentially by default.
– Selection structures
• C++ has three types - if, if/else, and switch
– Repetition structures
• C++ has three types - while, do/while, and for

10

## 2.4 Control Structures

• C++ keywords
– Cannot be used as identifiers or variable names.
C++ Keyw o rd s

## Keywords common to the

C and C++ programming
languages
auto break case char const
continue default do double else
enum extern float for goto
if int long register return
short signed sizeof static struct
switch typedef union unsigned void
volatile while
C++ only keywords
asm bool catch class const_cast
delete dynamic_cast explicit false friend
inline mutable namespace new operator
private protected public reinterpret_cast
static_cast template this throw true
try typeid typename using virtual
wchar_t

11
2.4 Control Structures
• Flowchart
– Graphical representation of an algorithm
– Drawn using certain special-purpose symbols connected by
arrows called flowlines.
– Rectangle symbol (action symbol)
• Indicates any type of action.
– Oval symbol
• indicates beginning or end of a program, or a section of code
(circles).
– Diamond symbol (decision symbol)
• indicates decision is to be made
• single-entry/single-exit control structures
– Connect exit point of one control structure to entry point of
the next (control-structure stacking).
– Makes programs easy to build.
12

## 2.5 The if Selection Structure

• Selection structure
– used to choose among alternative courses of action
– Pseudocode example:
If student’s grade is greater than or equal to 60
Print “Passed”
– If the condition is true
• print statement executed and program goes on to next
statement
– If the condition is false
• print statement is ignored and the program goes onto the next
statement
– Indenting makes programs easier to read
• C++ ignores whitespace characters

13

## • Translation of pseudocode statement into C++:

if ( grade >= 60 )
cout << "Passed";
• Diamond symbol (decision symbol)
– indicates decision is to be made
– Contains an expression that can be true or false.
• Test the condition, follow appropriate path
• if structure is a single-entry/single-exit structure

14

any expression.

## true zero - false

nonzero - true
Example:
false 3 - 4 is true

15

## 2.6 The if/else Selection Structure

• if
– Only performs an action if the condition is true
• if/else
– A different action is performed when condition is true and
when condition is false
• Psuedocode
if student’s grade is greater than or equal to 60
print “Passed”
else
print “Failed”
• C++ code
if ( grade >= 60 )
cout << "Passed";
else
cout << "Failed";

16

false true

## print “Failed” print “Passed”

• C++ code
if ( grade >= 60 )
cout << "Passed";
else
cout << "Failed";

17

false true

## • Ternary conditional operator (?:)

– Takes three arguments (condition, value if true, value if false)
• Our pseudocode could be written:
cout << ( grade >= 60 ? “Passed” : “Failed” );

18

## Ternary conditional operator

• Nested if/else structures
– Test for multiple cases by placing if/else selection
structures inside if/else selection structures.
if student’s grade is greater than or equal to 90
Print “A”
else
if student’s grade is greater than or equal to 80
Print “B”
else
if student’s grade is greater than or equal to 70
Print “C”
else
if student’s grade is greater than or equal to 60
Print “D”
else
Print “F”
– Once a condition is met, the rest of the statements are skipped
19

## 2.6 The if/else Selection Structure

• Compound statement:
– Set of statements within a pair of braces
– Example:
if ( grade >= 60 )
cout << "Passed.\n";
else {
cout << "Failed.\n";
cout << "You must take this course again.\n";
}
– Without the braces,
cout << "You must take this course again.\n";
would be automatically executed
• Block
– Compound statements with declarations

20

## 2.6 The if/else Selection Structure

• Syntax errors
– Errors caught by compiler
• Logic errors
– Errors which have their effect at execution time
• Non-fatal logic errors
– program runs, but has incorrect output
• Fatal logic errors
– program exits prematurely

21
The switch Multiple-Selection
Statement
• switch
– Useful when a variable or expression is tested for all the values it
can assume and different actions are taken
• Format
– Series of case labels and an optional default case
switch ( value ){
case '1':
actions
case '2':
actions
default:
actions
}
– break; // exits from statement

22
Same actions taken for two cases
switch ( value ){
case '1':
case '2':
actions /* one or more statements */
break;

case '3':
case '4':
actions /* one or more statements */
break;

default:
actions /* one or more statements */
break;
}

2.16 The switch Multiple-Selection Structure
• switch
– Useful when variable or expression is tested for multiple values
– Consists of a series of case labels and an optional default case

true
case a case a action(s) break
false

true
case b case b action(s) break
false

.
.
.

true
case z case z action(s) break
false

default action(s)

24
2.7 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;

25

## • Flowchart of while loop

true
product <= 1000 product = 2 * product

false

26
2.8 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.

27
2.8 Formulating Algorithms (Counter-
Controlled Repetition)
• Pseudocode for example:
Set total to zero total = 0

While grade counter is less than or equal to ten while (gradeCounter ≤ 10)

Set the class average to the total divided by ten average = total / 10
Print the class average Print average

## • Following is the C++ code for this example

1 // Fig. 2.7: fig02_07.cpp 28
2 // Class average program with counter-controlled repetition Outline
3 #include <iostream.h>
4
9 int main() 1. Initialize Variables
10 {
11 int total, // sum of grades 2. Execute Loop
14 average; // average of grades
16 // initialization phase
17 total = 0; // clear total
18 gradeCounter = 1; // prepare to loop
21 while ( gradeCounter <= 10 ) { The counter
// loop gets incremented each
10 times
time the loop executes. Eventually, the
20 // processing phase
counter causes the loop to end.
22 cout << "Enter grade: "; // prompt for input
total
counter
26 }
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 }
29
Outline
Class average is 81

30
2.9 Formulating Algorithms with Top-
Down, Stepwise Refinement (Sentinel-
Controlled Repetition)
• Suppose the 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”
– Loop ends when sentinel is inputted
– Sentinel value chosen so it cannot be confused with a regular
input (such as -1 in this case)

31

## 2.9 Formulating Algorithms with Top-

Down, Stepwise Refinement (Sentinel-
Controlled Repetition)
• 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

32
2.9 Formulating Algorithms with Top-
Down, Stepwise Refinement
• Many programs can be divided into three phases:
– Initialization
• Initializes the program variables
– Processing
• Inputs data values and adjusts program variables accordingly
– Termination
• Calculates and prints the final results.
• Helps the breakup of programs for top-down refinement.
• Refine the initialization phase from Recall the program
to control average
Initialize variables grade of the class
to
Initialize total to zero total = 0
Initialize counter to zero gradeCounter = 1

33
2.9 Formulating Algorithms with Top-
Down, Stepwise Refinement
• Refine Processing step
Input, sum and count the quiz grades
to
While the user has not as yet entered the sentinel while continue
• Refine Termination step
Calculate and print the class average
to
If the counter is not equal to zero
Set the average to the total divided by the counter average = total / 10
Print the average Print average
Else
34
1 // Fig. 2.9: fig02_09.cpp Outline
2 // Class average program with sentinel-controlled
repetition.
3 #include <iostream.h> 1. Initialize Variables
4 #include <iomanip.h>
5 int main()
Data type float used to represent 2. Get user input
6 { decimal numbers.
7 int total, // sum of grades
2.1 Perform Loop
10 float average; // number with decimal point for average
11
12 // initialization phase
13 total = 0;
15
16 // processing phase
17 cout << "Enter grade, -1 to end: ";
19
20 while ( grade != -1 ) {
21 total = total + grade;
23 cout << "Enter grade, -1 to end: ";
25 }
35
26 Outline
27 // termination phase
28 if ( gradeCounter != 0 ) { 3. Calculate Average
29 average = (float )( total ) / gradeCounter;
30 cout << "Class average is " << setprecision( 2 )
31 << setiosflags( iostream::fixed | iostream::showpoint )
32 << average << endl;
33 } 3.1 Print Results
34 else
35 cout << "No grades were entered" << endl;| iostream::showpoint) - stream
=-iostream::fixed
36 setprecision(2) - prints only two digits
(float)(total) - treats totalmanipulator
as a double
37 return 0; // indicate program ended past decimal point.
successfully
temporarily.
38 }
iostream::fixed - output
Programs numbers
that use withinclude
this must a fixed number of
Required
Enter because
to end:two75
integers truncates the
decimal points.
<iomanip.h>
Enter grade, -1 to end: 94
remainder.
Enter grade, -1 to end: 97 iostream::showpoint - forces decimal point and trailing zeros,
Enter grade, -1 to end: 88
gradeCounter is an int, but it gets
evenpromoted to
if unnecessary: 66 printed as 66.00
double. -1 to end: 70
Enter grade, -1 to end: 64 Program Output
Enter grade, -1 to end: 83 | - separates multiple option.
Enter grade, -1 to end: 89
Enter grade, -1 to end: -1
Class average is 82.50

36

37

Dry Run

## • “…a dry run is a mental run of an algorithm,

sometimes expressed in pseudocode, where the
computer scientist examines the algorithm's
procedures one step at a time.”
(Source: Wikipedia)

## • Use pen and paper to keep track of variable values

during a dry run.

38
2.9 Formulating Algorithms with Top-
Down, Stepwise Refinement

While the user has not as yet entered the
sentinel
Input the next grade (possibly the sentinel)

39
2.10 Nested control structures Outline

• 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
• one to count the number of students who failed the exam.
– Each test result is a number— either a 1 or a 2. If the number is
not a 1, we assume that it is a 2.

40
Outline
2.10 Nested control structures

## • Top level outline:

Analyze exam results and decide if tuition should be raised
• First Refinement:
Initialize variables
Input the ten quiz grades and count passes and failures
Print a summary of the exam results and decide if tuition
should be raised
• Refine
Initialize variables
to
Initialize passes to zero passes = 0
Initialize failures to zero failures = 0
Initialize student counter to one studentCounter = 1

41
Outline
2.10 Nested control structures
• Refine
Input the ten quiz grades and count passes and failures
to
While student counter is less than or equal to ten while ( studentCounter ≤ 10 )
Input the next exam result input result
If the student passed If (result = 1)
Add one to passes passes = passes + 1
Else Else
Add one to failures failures = failures + 1
Add one to student counter studentCounter =studentCounter+ 1

• Refine
Print a summary of the exam results and decide if tuition should be raised
to
Print the number of passes Print passes
Print the number of failures Print failures
If more than eight students passed if passes > 8
Print “Raise tuition” Print “Raise tuition
1 // Fig. 2.11: fig02_11.cpp 42
2 // Analysis of examination results Outline
3 #include <iostream.h>
4 int main() 1. Initialize variables
5 {
6 // initialize variables in declarations 2. Input data and
count passes/failures
7 int passes = 0, // number of passes
8 failures = 0, // number of failures
9 studentCounter = 1, // student counter
10 result; // one exam result
11
12 // process 10 students; counter-controlled loop
13 while ( studentCounter <= 10 ) {
14 cout << "Enter result (1=pass,2=fail): ";
15 cin >> result;
16
17 if ( result == 1 ) // if/else nested in while
18 passes = passes + 1;
19 else
20 failures = failures + 1;
21
22 studentCounter = studentCounter + 1;
23 }

43
24 Outline
25 // termination phase
26 cout << "Passed " << passes << endl;
3. Print results
27 cout << "Failed " << failures << endl;
28
29 if ( passes > 8 )
30 cout << "Raise tuition " << endl;
31
32 return 0; // successful termination
33 }

## 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 Program Output
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

44

## • Assignment expression abbreviations

c = c + 3; can be abbreviated as c += 3; using the
• 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)
e *= 5 (e = e * 5)
f /= 3 (f = f / 3)
g %= 9 (g = g % 9)

45

## 2.12 Increment and Decrement Operators

• Increment operator (++) - can be used instead of
c += 1
• Decrement operator (--) - can be used instead of
c -= 1
– Preincrement
• When the operator is used before the variable (++c or ––c)
• Variable is changed, then the expression, it is in, is evaluated.
– Posincrement
• When the operator is used after the variable (c++ or c--)
• Expression the variable is in executes, then the variable is changed.
• 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)
46

## • When Variable is not in an expression

– Preincrementing and postincrementing have the
same effect.
++c; If c was originally 5
cout << c;
What will be Output ?
and
c++; 6

cout << c;
have the same effect.

47
Some Examples – Nested Loop
*
- Nested While Loop **
***
1. Write a program to print a triangle of ‘*’ ****
– Use 2 counters, one each for row counter *****

## and column counter

– Each time the columns will start from one, so the counter for
column must be initialized inside the first while loop
– The row counter and column count have be increment inside first
while and outside second while (except the column counter)
2. Practice questions
- print a square of ‘*’ using nested while loop, rows
and column are given.
- Print a triangle as above but use sentinel repetition
control
48
Some Examples - Operators
#include<iostream.h> c = (a++) + (b++) 

## #include<conio.h> c = a + b = 5 + 6 = 11 the summation result is stored

a++ = 6
void main(){ in c before the post increments
b++ = 7
int a = 5; int b= 6;
int c = (a++) + (b++); clrscr(); Screen Output
cout<<"\na = "<<a;
cout<<"\nb = "<<b; a=6
cout<<"\nc = "<<c; b=7
c = 11
int x=4; int y=4;
int z = (x++) - (--y); x=5
cout<<"\n\nx = "<<x; y=3
z = (x++) – (--y) 
cout<<"\ny = "<<y; z =1
--y = 3
cout<<"\nz= "<<z;
z=4–3=1
x++ = 5
49
Some Examples
Screen Output
int k; float f;
x = 5; y = 3; x/y = 1
cout<<"\n\nx/y = "<<x/y;
f = x/y; f = x/y = 1
cout<<"\n\nf = x/y = "<<f;
k = (float)(x/y); k = (float)(x/y) = 1
cout<<"\n\nk = (float)(x/y) = "<<k;
f = (float)(x/y); f = (float)(x/y) = 1
cout<<"\n\nf = (float)(x/y)= "<<f; (float)(x/y) = 1
cout<<"\n\n(float)(x/y) = "<<(float)(x/y);
cout<<"\n\n(float)x /y = "<<(float)x /y; (float)x /y = 1.6666667
cout<<"\n\n1.5 /3 = "<< 1.5/3; 1.5/3 = 0.5
cout<<"\n\n1/3.0 = "<< 1/3.0;
getch(); 1/3.0 = 0.333333
}

50
2.13 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.
– Body (optional)
• Example:
int counter =1; //initialization
while (counter <= 10){ //repetition condition
cout << counter << endl;
++counter; //increment
}
51
2.13 Essentials of Counter-Controlled
Repetition
• The declaration
int counter = 1;
– Names counter
– Declares counter to be an integer
– Reserves space for counter in memory
– Sets counter to an initial value of 1

52

## • 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
No
semicolon
after last
statement

53

## for keyword Control variable name Final value of the

control variable for the
condition is true

## Initial value of control variable Increment of control vari

Loop-continuation condition

54

## • 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;

55

## • Format when using for loops

for ( initialization; loopContinuationTest; increment )
statement
----------------------------------------------------------------------------------------

## for ( initialization; loopContinuationTest; increment ) {

statement1
statement2
.. No
semicolon
statementN (;) after last
} expression

• Example:
for( int counter = 1; counter <= 10; counter++ )
cout<<“\n“<< counter;
– Prints the integers from one to ten

56

## • Flowchart of while loop

true
product <= 1000 product = 2 * product

false

57

## The for Statement :

Establish initial
value of control
variable
counter
counter = 1
= 1

true
counter <= 10 Cout<<“\n” <<counter ; counter++
Increment
the control
Determine if final false Body of loop variable
value of control (this may be many
variable has been statements)
reached
counter = 1
Initialization placed before
the while statement

while Statement
true
counter <= 10 Cout<<“\n” <<counter ;
counter++
false
Counter integrated into the
1 /* Fig. 4.2: fig04_02.c 58
2 Counter-controlled repetition with the for statement */ Outline
3 #include <iostream.h>
fig04_02.c
4
5 /* function main begins program execution */
6 int main()
7 {
8 int counter; /* define counter */
9
10 /* initialization, repetition condition, and increment
11 are all included in the for statement header. */
12 for ( counter = 1; counter <= 10; counter++ ) {
13 cout<<”\n” << counter ;
14 } /* end for */
15
16 return 0; /* indicate program ended successfully */
17
18 } /* end function main */

59
2.14 The for Statement : Notes and
Observations
• Arithmetic expressions
– Initialization, loop-continuation, and increment can contain
arithmetic expressions. If x equals 2 and y equals 10
for ( j = x; j <= 4 * x * y; j += y / x )
is equivalent to
for ( j = 2; j <= 80; j += 5 )

## • Notes about the for statement:

– "Increment" may be negative (decrement)
– If the loop continuation condition is initially false
• The body of the for statement is not performed
• Control proceeds with the next statement after the for statement
– Control variable
• Often printed or used inside for body, but not necessary

60

## The for Statement :

Establish initial
value of control
variable
counter
counter = 1
= 1

true
counter <= 10 Cout<<“\n” <<counter ; counter++
Increment
the control
Determine if final false Body of loop variable
value of control (this may be many
variable has been statements)
reached

61

## 2.15 Examples Using the for Structure

• Program to sum the even numbers from 2 to 100
1 // Fig. 2.20: fig02_20.cpp
2 // Summation with for
3 #include <iostream.h>
4

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 }

Sum is 2550

1 /* Fig. 4.6: fig04_06.c
62
2 Calculating compound interest */ Outline
3 #include <iostream.h>
4 #include <math.h>
fig04_06.c (Part 1 of 2)
5
6 /* function main begins program execution */
7 int main()
8 {
9 double amount; /* amount on deposit */
10 double principal = 1000.0; /* starting principal */
11 double rate = .05; /* interest rate */
12 int year; /* year counter */
13
14 /* output table column head */
15 cout<< "Year \t Amount on deposit" ;
16
17 /* calculate amount on deposit for each of ten years */
18 for ( year = 1; year <= 10; year++ ) {
19
20 /* calculate new amount for specified year */
21 amount = principal * pow( 1.0 + rate, year );
22
23 /* output one table row */
24 cout<< year<<” \t ” << amount ;
25 } /* end for */
26

27 return 0; /* indicate program ended successfully */
63
28 Outline
29 } /* end function main */

fig04_06.c (Part 2 of 2)

## 04 character places Program Output

21 character places

1 1050.00
2 1102.50
3 1157.63
4 1215.51
5 1276.28
6 1340.10
7 1407.10
8 1477.46
9 1551.33
10 1628.89

64

## 2.17 The do/while Repetition Structure

• The do/while repetition structure is similar to the
while structure,
– Condition for repetition tested after the body of the loop is
executed
• Format:
do {
statement
} while ( condition );
action(s)

## • Example (letting counter = 1):

do {
cout << counter << " "; true
condition
} while (++counter <= 10);
– This prints the integers from 1 to 10 false

## • All actions are performed at least once.

2.17 The do…while Repetition Statement

## • Flowchart of the do…while repetition statement

action(s)

true
condition

false

2.17 COMPARISON: The while Repetition
Statement
• Flowchart of the while repetition statement

condition action(s)
true

false

67

## 2.18 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

1
2 Using the break statement in a for statement */
3 #include <io.streamh>
4
5 /* function main begins program
1 2 3execution
4 */
6 int main() Broke out of loop at x == 5
7 {
8 int x; /* counter */
9 /* loop 10 times */
10 for ( x = 1; x <= 10; x++ ) {
11 /* if x is 5, terminate loop */
12 if ( x == 5 ) {
13 break; /* break loop only if x is 5 */
14 } /* end if */
15 cout<< x; /* display value of x */
16 } /* end for */
17 cout<< "\nBroke out of loop at x == \n" << x ;
18 return 0; /* indicate program ended successfully */

69

## 2.18 The break and continue Statements

• 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

1
2 Using the continue statement in a for statement */
3 #include <stdio.h>
fig04_12.c
5 /* function main begins program execution */
6 int main() 1 2 3 4 6 7 8 9 10
7 { Used continue to skip printing the value 5
8 int x; /* counter */
10 /* loop 10 times */
11 for ( x = 1; x <= 10; x++ ) {
13 /* if x is 5, continue with next iteration of loop */
14 if ( x == 5 ) {
15 continue; /* skip remaining code in loop body
*/
16 } /* end if */
18 cout<< "%d "<< x ; /* display value of x */
19 } /* end for */
21 cout<< "\nUsed continue to skip printing the value
5\n";
23 return 0; /* indicate program ended successfully */
71

## 2.19 Logical Operators

• && (logical AND)
– Returns true if both conditions are true
• || (logical OR)
– Returns true if either of its conditions are true
• ! (logical NOT, logical negation)
– Reverses the truth/falsity of its condition
– Returns true when its condition is false
– Is a unary operator, only takes one condition
• Logical operators used as conditions in loops
Expression Result
true && false false
true || false true
!false true

72
2.20 Confusing Equality (==) and
Assignment (=) Operators
• These errors are damaging because they do not
ordinarily cause syntax errors.
– Recall that any expression that produces a value can be used in
control structures. Nonzero values are true, and zero values
are false
• Example:
if ( payCode == 4 )
cout << "You get a bonus!" << endl;
– Checks the paycode, and if it is 4 then a bonus is awarded
• If == was replaced with =
if ( payCode = 4 )
cout << "You get a bonus!" << endl;
– Sets paycode to 4
– 4 is nonzero, so the expression is true and a bonus is awarded,
regardless of paycode.
73
2.20 Confusing Equality (==) and
Assignment (=) Operators
• Lvalues
– Expressions that can appear on the left side of an equation
– Their values can be changed
– Variable names are a common example (as in x = 4;)
• Rvalues
– Expressions that can only appear on the right side of an
equation
– Constants, such as numbers (i.e. you cannot write 4 = x;)
• Lvalues can be used as rvalues, but not vice versa

74
Operator precedence examples

75
2.16 The switch Multiple-Selection
Statement
• switch
– Useful when a variable or expression is tested for all the
values it can assume and different actions are taken
• Format
– Series of case labels and an optional default case
switch ( value ){
case '1':
actions
case '2':
actions
default:
actions
}
– break; exits from statement

76

## Same actions taken for two cases

switch ( value ){
case '1':
case '2':
actions /* one or more statements */
break;

case '3':
case '4':
actions /* one or more statements */
break;

default:
actions /* one or more statements */
break;
}

77

## 2.16 The switch Multiple-Selection Structure

• switch
– Useful when variable or expression is tested for multiple values
– Consists of a series of case labels and an optional default case

true
case a case a action(s) break

false

true
case b case b action(s) break
false

.
.
.

true
case z case z action(s) break

false

default action(s)

1 // Fig. 2.22: fig02_22.cpp 78
3 #include <iostream.h>
4
5 1. Initialize variables
6
7
8 2. Input data
9 int main()
10 {
2.1 Use switch loop to
12 aCount = 0, // number of A's update count
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 = cin.get() ) != 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;
35 case 'C': // grade was uppercase C 79
36 case 'c': // or lowercase c
37 ++cCount;
38 break;
39 2.1 Use switch loop to
40 case 'D': // grade was uppercase D
break causes switch to end and update count
41 case 'd': // or lowercase d
42 ++dCount; the program continues with the first
43 break; statement after the switch
44 3. Print results
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 case ' ': // and spaces in input Notice 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 
80
Enter the EOF character to end input.
a
B
Program Output
c
C
A
d
f
C
E
D
A
b

A: 3
B: 2
C: 3
D: 2
F: 1

81

## 2.17 The do/while Repetition Structure

• The do/while repetition structure is similar to the
while structure,
– Condition for repetition tested after the body of the loop is
executed
• Format:
do {
statement
} while ( condition );
action(s)

## • Example (letting counter = 1):

do {
cout << counter << " "; true
condition
} while (++counter <= 10);
– This prints the integers from 1 to 10 false

## • All actions are performed at least once.

2.17 The do…while Repetition Statement

## • Flowchart of the do…while repetition statement

action(s)

true
condition

false

2.17 COMPARISON: The while Repetition
Statement
• Flowchart of the while repetition statement

condition action(s)
true

false

84
2.21 Structured-Programming Summary

• Structured programming
– Programs are easier to understand, test, debug and, modify.
• Rules for structured programming
– Only single-entry/single-exit control structures are used
– Rules:
1) Begin with the “simplest flowchart”.
2) Any rectangle (action) can be replaced by two rectangles
(actions) in sequence.
3) Any rectangle (action) can be replaced by any control
structure (sequence, if, if/else, switch, while, do/while or for).
4) Rules 2 and 3 can be applied in any order and multiple times.

85
2.21 Structured-Programming Summary

## Representation of Rule 3 (replacing any rectangle with a control structure)

Rule 3

Rule 3 Rule 3

86
2.21 Structured-Programming Summary

## • All programs can be broken down into

– Sequence
– Selection
• if, if/else, or switch
• Any selection can be rewritten as an if statement
– Repetition
• while, do/while or for
• Any repetition structure can be rewritten as a while statement

87

## • for(num2 = 0; num2 <= 3; num2++)

{
for(num1 = 0; num1 <= 2; num1++)
{
cout<< num2<< " " << num1<< endl;
}
}

http://mathbits.com/mathbits/compsci/looping/nested.htm
88

## for(num2 = 0; num2 <= 3; num2++)

{
for(num1 = 0; num1 <= 2; num1++)
{
cout<< num2<< " " << num1<< endl;
}
}

http://mathbits.com/mathbits/compsci/looping/nested.htm