1

4
C Program
Control

 2007 Pearson Education, Inc. All rights reserved.

 2

OBJECTIVES
In this chapter you will learn:
 The essentials of counter-controlled repetition.
 To use the for and do...while repetition statements to
execute statements in a program repeatedly.
 To understand multiple selection using the switch
selection statement.
 To use the break and continue program control statements
to alter the flow of control.
 To use the logical operators to form complex conditional
expressions in control statements.
 To avoid the consequences of confusing the equality and
assignment operators.

 2007 Pearson Education, Inc. All rights reserved.

 3

4.1 Introduction
4.2 Repetition Essentials
4.3 Counter-Controlled Repetition
4.4 for Repetition Statement
4.5 for Statement: Notes and Observations
4.6 Examples Using the for Statement
4.7 switch Multiple-Selection Statement
4.8 do...while Repetition Statement
4.9 break and continue Statements
4.10 Logical Operators
4.11 Confusing Equality (==) and Assignment (=) Operators
4.12 Structured Programming Summary

 2007 Pearson Education, Inc. All rights reserved.

 4

4.1 Introduction
 This chapter introduces
– Additional repetition control structures
- for
- do…while
– switch multiple selection statement
– break statement
- Used for exiting immediately and rapidly from certain
control structures
– continue statement
- Used for skipping the remainder of the body of a repetition
structure and proceeding with the next iteration of the loop

 2007 Pearson Education, Inc. All rights reserved.

 5

4.2 Repetition Essentials

 Loop
– Group of instructions computer executes repeatedly while
some condition remains true
 Counter-controlled repetition
– Definite repetition: know how many times loop will execute
– Control variable used to count repetitions
 Sentinel-controlled repetition
– Indefinite repetition
– Used when number of repetitions not known
– Sentinel value indicates "end of data"

 2007 Pearson Education, Inc. All rights reserved.

 6

4.3 Counter-Controlled Repetition

 Counter-controlled repetition requires
– The name of a control variable (or loop counter)
– The initial value of the control variable
– An increment (or decrement) by which the control variable
is modified each time through the loop
– A condition that tests for the final value of the control
variable (i.e., whether looping should continue)

 2007 Pearson Education, Inc. All rights reserved.

 7

4.3 Counter-Controlled Repetition

 Example:
int counter = 1; // initialization
while ( counter <= 10 ) { // repetition condition
printf( "%d\n", counter );
++counter; // increment
}
– The statement
int counter = 1;
- Names counter
- Defines it to be an integer
- Reserves space for it in memory
- Sets it to an initial value of 1

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.1: fig04_01.c 8
2 Counter-controlled repetition */
3 #include <stdio.h>
Outline
4
5 /* function main begins program execution */
6 int main( void )
fig04_01.c
7 {
8 int counter = 1; /* initialization */ Definition and assignment are performed
9 simultaneously
10 while ( counter <= 10 ) { /* repetition condition */
11 printf ( "%d\n", counter ); /* display counter */
12 ++counter; /* increment */
13 } /* end while */
14
15 return 0; /* indicate program ended successfully */
16
17 } /* end function main */

1
2
3
4
5
6
7
8
9
10

 2007 Pearson Education,

Inc. All rights reserved.
 9

4.3 Counter-Controlled Repetition

 Condensed code
– C Programmers would make the program more concise
– Initialize counter to 0
- while ( ++counter <= 10 )
printf( “%d\n, counter );

 2007 Pearson Education, Inc. All rights reserved.

 10

Common Programming Error 4.1

Because floating-point values may be

approximate, controlling counting loops
with floating-point variables may result in
imprecise counter values and inaccurate
tests for termination.

 2007 Pearson Education, Inc. All rights reserved.

 11

Error-Prevention Tip 4.1

Control counting loops with integer values.

 2007 Pearson Education, Inc. All rights reserved.

 12

Good Programming Practice 4.1

Indent the statements in the body of each

control statement.

 2007 Pearson Education, Inc. All rights reserved.

 13

Good Programming Practice 4.2

Put a blank line before and after each

control statement to make it stand out in a
program.

 2007 Pearson Education, Inc. All rights reserved.

 14

Good Programming Practice 4.3

Too many levels of nesting can make a

program difficult to understand. As a
general rule, try to avoid using more than
three levels of nesting.

 2007 Pearson Education, Inc. All rights reserved.

 15

Good Programming Practice 4.4

The combination of vertical spacing before

and after control statements and indentation
of the bodies of control statements within the
control-statement headers gives programs a
two-dimensional appearance that greatly
improves program readability.

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.2: fig04_02.c 16
2 Counter-controlled repetition with the for statement */
3 #include <stdio.h>
Outline
4
5 /* function main begins program execution */
6 int main( void )
fig04_02.c
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++ ) { for loop begins by setting counter to 1
13 printf( "%d\n", counter );
and repeats while counter <= 10.
14 } /* end for */
15 Each time the end of the loop is reached,
16 return 0; /* indicate program ended successfully */ counter is incremented by 1.
17
18 } /* end function main */

 2007 Pearson Education,

Inc. All rights reserved.
 17

Fig. 4.3 | for statement header components.

 2007 Pearson Education, Inc. All rights reserved.

 18

Common Programming Error 4.2

Using an incorrect relational operator or

using an incorrect initial or final value of a
loop counter in the condition of a while or
for statement can cause off-by-one errors.

 2007 Pearson Education, Inc. All rights reserved.

 19

Error-Prevention Tip 4.2

Using the final value in the condition of a while

or for statement and using the <= relational
operator will help avoid off-by-one errors. For a
loop used to print the values 1 to 10, for
example, the loop-continuation condition should
be counter <= 10 rather than counter < 11
or counter < 10.

 2007 Pearson Education, Inc. All rights reserved.

 20

4.4 for Repetition Statement

 Format when using for loops
for ( initialization; loopContinuationTest; increment )
statement
 Example:
for( int counter = 1; counter <= 10; counter++ )
printf( "%d\n", counter );
– Prints the integers from one to ten

 2007 Pearson Education, Inc. All rights reserved.

 21

4.4 for Repetition Statement

 For loops can usually be rewritten as while loops:
initialization;
while ( loopContinuationTest ) {
statement;
increment;
}
 Initialization and increment
– Can be comma-separated lists
– Example:
for (int i = 0, j = 0; j + i <= 10; j++,
i++)
printf( "%d\n", j + i );

 2007 Pearson Education, Inc. All rights reserved.

 22

Software Engineering Observation 4.1

Place only expressions involving the control

variables in the initialization and increment
sections of a for statement. Manipulations
of other variables should appear either
before the loop (if they execute only once,
like initialization statements) or in the loop
body (if they execute once per repetition, like
incrementing or decrementing statements).

 2007 Pearson Education, Inc. All rights reserved.

 23

Common Programming Error 4.3

Using commas instead of semicolons in a

for header is a syntax error.

 2007 Pearson Education, Inc. All rights reserved.

 24

Common Programming Error 4.4

Placing a semicolon immediately to the

right of a for header makes the body of
that for statement an empty statement.
This is normally a logic error.

 2007 Pearson Education, Inc. All rights reserved.

 25

4.5 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

 2007 Pearson Education, Inc. All rights reserved.

 26

Error-Prevention Tip 4.3

Although the value of the control variable

can be changed in the body of a for loop,
this can lead to subtle errors. It is best not
to change it.

 2007 Pearson Education, Inc. All rights reserved.

 27

Fig. 4.4 | Flowcharting a typical for repetition statement.

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.5: fig04_05.c 28
2 Summation with for */
3 #include <stdio.h>
Outline
4
5 /* function main begins program execution */
6 int main( void )
fig04_05.c
7 {
8 int sum = 0; /* initialize sum */
9 int number; /* number to be added to sum */
10
11 for ( number = 2; number <= 100; number += 2 ) {
12 sum += number; /* add number to sum */ Note that number has a different value
13 } /* end for */
14
each time this statement is executed
15 printf( "Sum is %d\n", sum ); /* output sum */
16
17 return 0; /* indicate program ended successfully */
18
19 } /* end function main */

Sum is 2550

 2007 Pearson Education,

Inc. All rights reserved.
 29

Good Programming Practice 4.5

Although statements preceding a for and

statements in the body of a for can often be
merged into the for header, avoid doing so
because it makes the program more difficult
to read.

 2007 Pearson Education, Inc. All rights reserved.

 30

Good Programming Practice 4.6

Limit the size of control-statement headers

to a single line if possible.

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.6: fig04_06.c 31
2 Calculating compound interest */
3 #include <stdio.h>
Outline
4 #include <math.h> additional header
5
6 /* function main begins program execution */
fig04_06.c
7 int main( void )
8 {
9 double amount; /* amount on deposit */
(1 of 2 )
10 double principal = 1000.0; /* starting principal */
11 double rate = .05; /* annual interest rate */
12 int year; /* year counter */
13
14 /* output table column head */
15 printf( "%4s%21s\n", "Year", "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 );
pow function calculates the value of the
22 first argument raised to the power of
23 /* output one table row */ the second argument
24 printf( "%4d%21.2f\n", year, amount );
25 } /* end for */
26
27 return 0; /* indicate program ended successfully */
28
29 } /* end function main */

 2007 Pearson Education,

Inc. All rights reserved.
 32
Year Amount on deposit Outline
1 1050.00
2 1102.50
3 1157.63
4 1215.51 fig04_06.c
5 1276.28
6 1340.10 (2 of 2 )
7 1407.10
8 1477.46
9 1551.33
10 1628.89

 2007 Pearson Education,

Inc. All rights reserved.
 33

Error-Prevention Tip 4.4

Do not use variables of type float or

double to perform monetary calculations.
The impreciseness of floating-point
numbers can cause errors that will result in
incorrect monetary values.

 2007 Pearson Education, Inc. All rights reserved.

 34

4.7 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

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.7: fig04_07.c 35
2 Counting letter grades */
3 #include <stdio.h>
Outline
4
5 /* function main begins program execution */
6 int main( void )
fig04_07.c
7 {
8 int grade; /* one grade */
9 int aCount = 0; /* number of As */
(1 of 4 )
10 int bCount = 0; /* number of Bs */
11 int cCount = 0; /* number of Cs */
12 int dCount = 0; /* number of Ds */
13 int fCount = 0; /* number of Fs */
14
15 printf( "Enter the letter grades.\n" );
16 printf( "Enter the EOF character to end input.\n" );
17
18 /* loop until user types end-of-file key sequence */
19 while ( ( grade = getchar() ) != EOF ) {
20
EOF stands for “end of file;” this character varies
21 /* determine which grade was input */ from system to system
22 switch ( grade ) { /* switch nested in while */
23 switch statement checks each of its nested
24 case 'A': /* grade was uppercase A */ cases for a match
25 case 'a': /* or lowercase a */
26 ++aCount; /* increment aCount */
27 break; /* necessary to exit switch */
28

break statement makes program skip to end of switch

 2007 Pearson Education,
Inc. All rights reserved.
29 case 'B': /* grade was uppercase B */ 36
30 case 'b': /* or lowercase b */
31 ++bCount; /* increment bCount */
Outline
32 break; /* exit switch */
33
34 case 'C': /* grade was uppercase C */
fig04_07.c
35 case 'c': /* or lowercase c */
36 ++cCount; /* increment cCount */
37 break; /* exit switch */
(2 of 4 )
38
39 case 'D': /* grade was uppercase D */
40 case 'd': /* or lowercase d */
41 ++dCount; /* increment dCount */
42 break; /* exit switch */
43
44 case 'F': /* grade was uppercase F */
45 case 'f': /* or lowercase f */
46 ++fCount; /* increment fCount */
47 break; /* exit switch */
48
49 case '\n': /* ignore newlines, */
50 case '\t': /* tabs, */
51 case ' ': /* and spaces in input */
52 break; /* exit switch */
53

 2007 Pearson Education,

Inc. All rights reserved.
54 default: /* catch all other characters */ 37
55 printf( "Incorrect letter grade entered." );
56 printf( " Enter a new grade.\n" );
Outline
57 break; /* optional; will exit switch anyway */ default case occurs if none of the
58 } /* end switch */ cases are matched
59
fig04_07.c
60 } /* end while */
61
62 /* output summary of results */
(3 of 4 )
63 printf( "\nTotals for each letter grade are:\n" );
64 printf( "A: %d\n", aCount ); /* display number of A grades */
65 printf( "B: %d\n", bCount ); /* display number of B grades */
66 printf( "C: %d\n", cCount ); /* display number of C grades */
67 printf( "D: %d\n", dCount ); /* display number of D grades */
68 printf( "F: %d\n", fCount ); /* display number of F grades */
69
70 return 0; /* indicate program ended successfully */
71
72 } /* end function main */

 2007 Pearson Education,

Inc. All rights reserved.
 38
Enter the letter grades.
Enter the EOF character to end input. Outline
a
b
c
C
A fig04_07.c
d
f
C (4 of 4 )
E
Incorrect letter grade entered. Enter a new grade.
D
A
b
^Z

Totals for each letter grade are:

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

 2007 Pearson Education,

Inc. All rights reserved.
 39

Portability Tip 4.1

The keystroke combinations for entering

EOF (end of file) are system dependent.

 2007 Pearson Education, Inc. All rights reserved.

 40

Portability Tip 4.2

Testing for the symbolic constant EOF rather

than –1 makes programs more portable. The C
standard states that EOF is a negative integral
value (but not necessarily –1). Thus, EOF could
have different values on different systems.

 2007 Pearson Education, Inc. All rights reserved.

 41

Common Programming Error 4.5

Forgetting a break statement when one is

needed in a switch statement is a logic
error.

 2007 Pearson Education, Inc. All rights reserved.

 42

Fig. 4.8 | switch multiple-selection statement with breaks.

 2007 Pearson Education, Inc. All rights reserved.

 43

Good Programming Practice 4.7

Provide a default case in switch

statements. Cases not explicitly tested in a
switch are ignored. The default case helps
prevent this by focusing the programmer on
the need to process exceptional conditions.
There are situations in which no default
processing is needed.

 2007 Pearson Education, Inc. All rights reserved.

 44

Good Programming Practice 4.8

Although the case clauses and the

default case clause in a switch statement
can occur in any order, it is considered good
programming practice to place the default
clause last.

 2007 Pearson Education, Inc. All rights reserved.

 45

Good Programming Practice 4.9

In a switch statement when the

default clause is listed last, the break
statement is not required. But some
programmers include this break for
clarity and symmetry with other cases.

 2007 Pearson Education, Inc. All rights reserved.

 46

Common Programming Error 4.6

Not processing newline characters in the

input when reading characters one at a time
can cause logic errors.

 2007 Pearson Education, Inc. All rights reserved.

 47

Error-Prevention Tip 4.5

Remember to provide processing capabilities

for newline (and possibly other white-space)
characters in the input when processing
characters one at a time.

 2007 Pearson Education, Inc. All rights reserved.

 48

4.8 do…while Repetition Statement

 The do…while repetition statement
– Similar to the while structure
– Condition for repetition only tested after the body of the
loop is performed
- All actions are performed at least once
– Format:
do {
statement;
} while ( condition );

 2007 Pearson Education, Inc. All rights reserved.

 49

4.8 do…while Repetition Statement

 Example (letting counter = 1):
do {
printf( "%d ", counter );
} while (++counter <= 10);
– Prints the integers from 1 to 10

 2007 Pearson Education, Inc. All rights reserved.

 50

Good Programming Practice 4.10

Some programmers always include braces in

a do...while statement even if the braces
are not necessary. This helps eliminate
ambiguity between the do...while
statement containing one statement and the
while statement.

 2007 Pearson Education, Inc. All rights reserved.

 51

Common Programming Error 4.7

Infinite loops are caused when the loop-continuation

condition in a while, for or do...while
statement never becomes false. To prevent this,
make sure there is not a semicolon immediately after
the header of a while or for statement. In a
counter-controlled loop, make sure the control
variable is incremented (or decremented) in the
loop. In a sentinel-controlled loop, make sure the
sentinel value is eventually input.

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.9: fig04_09.c 52
2 Using the do/while repetition statement */
3 #include <stdio.h>
Outline
4
5 /* function main begins program execution */
6 int main( void )
fig04_09.c
7 {
8 int counter = 1; /* initialize counter */
9
10 do {
11 printf( "%d ", counter ); /* display counter */
12 } while ( ++counter <= 10 ); /* end do...while */ increments counter then checks if it is
13
14 return 0; /* indicate program ended successfully */
less than or equal to 10
15
16 } /* end function main */

1 2 3 4 5 6 7 8 9 10

 2007 Pearson Education,

Inc. All rights reserved.
 53

Fig. 4.10 | Flowcharting the do...while repetition statement.

 2007 Pearson Education, Inc. All rights reserved.

 54

4.9 break and continue Statements

 break
– Causes immediate exit from a while, for, do…while or
switch statement
– 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 statement

 2007 Pearson Education, Inc. All rights reserved.

1 /* Fig. 4.11: fig04_11.c 55
2 Using the break statement in a for statement */
3 #include <stdio.h>
Outline
4
5 /* function main begins program execution */
6 int main( void )
fig04_11.c
7 {
8 int x; /* counter */
9
10 /* loop 10 times */
11 for ( x = 1; x <= 10; x++ ) {
12
13 /* if x is 5, terminate loop */
14 if ( x == 5 ) {
15 break; /* break loop only if x is 5 */ break immediately ends for loop
16 } /* end if */
17
18 printf( "%d ", x ); /* display value of x */
19 } /* end for */
20
21 printf( "\nBroke out of loop at x == %d\n", x );
22
23 return 0; /* indicate program ended successfully */
24
25 } /* end function main */

1 2 3 4
Broke out of loop at x == 5

 2007 Pearson Education,

Inc. All rights reserved.
 56

4.9 break and continue Statements

 continue
– Skips the remaining statements in the body of a while,
for or do…while statement
- Proceeds with the next iteration of the loop
– while and do…while
- Loop-continuation test is evaluated immediately after the
continue statement is executed
– for
- Increment expression is executed, then the loop-continuation
test is evaluated

 2007 Pearson Education, Inc. All rights reserved.

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

1 2 3 4 6 7 8 9 10
Used continue to skip printing the value 5

 2007 Pearson Education,

Inc. All rights reserved.
 58

Software Engineering Observation 4.2

Some programmers feel that break and

continue violate the norms of structured
programming. Because the effects of these
statements can be achieved by structured
programming techniques we will soon learn,
these programmers do not use break and
continue.

 2007 Pearson Education, Inc. All rights reserved.

 59

Performance Tip 4.1

The break and continue statements,

when used properly, perform faster than the
corresponding structured techniques that we
will soon learn.

 2007 Pearson Education, Inc. All rights reserved.

 60

Software Engineering Observation 4.3

There is a tension between achieving

quality software engineering and achieving
the best-performing software. Often one of
these goals is achieved at the expense of the
other.

 2007 Pearson Education, Inc. All rights reserved.

 61

4.10 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
– Unary operator, has one operand
 Useful as conditions in loops
Expression Result
true && false false
true || false true
!false true

 2007 Pearson Education, Inc. All rights reserved.

 62

expression1 expression2 expression1 && expression2

0 0 0
0 nonzero 0
nonzero 0 0
nonzero nonzero 1

Fig. 4.13 | Truth table for the && (logical AND) operator.

 2007 Pearson Education, Inc. All rights reserved.

 63

expression1 expression2 expression1 || expression2

0 0 0
0 nonzero 1
nonzero 0 1
nonzero nonzero 1

Fig. 4.14 | Truth table for the logical OR (||) operator.

 2007 Pearson Education, Inc. All rights reserved.

 64

expression !expression

0 1
nonzero 0

Fig. 4.15 | Truth table for operator ! (logical negation).

 2007 Pearson Education, Inc. All rights reserved.

 65

Performance Tip 4.2

In expressions using operator &&, make the

condition that is most likely to be false the
leftmost condition. In expressions using
operator ||, make the condition that is
most likely to be true the leftmost condition.
This can reduce a program’s execution time.

 2007 Pearson Education, Inc. All rights reserved.

 66

Operators Associativity Type

++ (postfix) -- (postfix) right to left postfix

+ - ! ++ (prefix) -- (prefix) (type) right to left unary

* / % left to right multiplicative

+ - left to right additive

< <= > >= left to right relational

== != left to right equality

&& left to right logical AND

|| left to right logical OR

?: right to left conditional

= += -= *= /= %= right to left assignment

, left to right comma

Fig. 4.16 | Operator precedence and associativity.

 2007 Pearson Education, Inc. All rights reserved.

 67

4.11 Confusing Equality (==) and

Assignment (=) Operators
 Dangerous error
– Does not ordinarily cause syntax errors
– Any expression that produces a value can be used in
control structures
– Nonzero values are true, zero values are false
– Example using ==:
if ( payCode == 4 )
printf( "You get a bonus!\n" );
- Checks payCode, if it is 4 then a bonus is awarded

 2007 Pearson Education, Inc. All rights reserved.

 68

4.11 Confusing Equality (==) and

Assignment (=) Operators
- Example, replacing == with =:
if ( payCode = 4 )
printf( "You get a bonus!\n" );
This sets payCode to 4
4 is nonzero, so expression is true, and bonus awarded no
matter what the payCode was
– Logic error, not a syntax error

 2007 Pearson Education, Inc. All rights reserved.

 69

Common Programming Error 4.8

Using operator == for assignment or using

operator = for equality is a logic error.

 2007 Pearson Education, Inc. All rights reserved.

 70

4.11 Confusing Equality (==) and

Assignment (=) Operators
 lvalues
– Expressions that can appear on the left side of an equation
– Their values can be changed, such as variable names
- x = 4;

 rvalues
– Expressions that can only appear on the right side of an equation
– Constants, such as numbers
- Cannot write 4 = x;
- Must write x = 4;
– lvalues can be used as rvalues, but not vice versa
- y = x;

 2007 Pearson Education, Inc. All rights reserved.

 71

Good Programming Practice 4.11

When an equality expression has a variable and

a constant, as in x == 1, some programmers
prefer to write the expression with the constant
on the left and the variable name on the right
(e.g. 1 == x as protection against the logic error
that occurs when you accidentally replace
operator == with =.

 2007 Pearson Education, Inc. All rights reserved.

 72

Error-Prevention Tip 4.6

After you write a program, text search it

for every = and check that it is being used
properly.

 2007 Pearson Education, Inc. All rights reserved.

 73

Fig. 4.17 | C’s single-entry/single-exit sequence, selection and repetition statements.

 2007 Pearson Education, Inc. All rights reserved.

 74

4.12 Structured Programming Summary

 Structured programming
– Easier than unstructured programs to understand, test,
debug and, modify programs

 2007 Pearson Education, Inc. All rights reserved.

 75

Rules for Forming Structured Programs

1) Begin with the “simplest flowchart” (Fig. 4.19).

2) Any rectangle (action) can be replaced by two rectangles (actions) in sequence.
3) Any rectangle (action) can be replaced by any control statement (sequence, if,
if...else, switch, while, do...while or for).
4) Rules 2 and 3 may be applied as often as you like and in any order.

Fig. 4.18 | Rules for forming structured programs.

 2007 Pearson Education, Inc. All rights reserved.

 76

Fig. 4.19 | Simplest flowchart.

 2007 Pearson Education, Inc. All rights reserved.

 77

Fig. 4.20 | Repeatedly applying rule 2 of Fig. 4.18 to the simplest flowchart.

 2007 Pearson Education, Inc. All rights reserved.

 78

Fig. 4.21 | Applying rule 3 of Fig. 4.18 to the simplest flowchart.

 2007 Pearson Education, Inc. All rights reserved.

 79

Fig. 4.22 | Stacked, nested and overlapped building blocks.

 2007 Pearson Education, Inc. All rights reserved.

 80

Fig. 4.23 | An unstructured flowchart.

 2007 Pearson Education, Inc. All rights reserved.

 81

4.12 Structured Programming Summary

 All programs can be broken down into 3 controls

– Sequence – handled automatically by compiler
– Selection – if, if…else or switch
– Repetition – while, do…while or for
- Can only be combined in two ways
Nesting (rule 3)
Stacking (rule 2)
– Any selection can be rewritten as an if statement, and any
repetition can be rewritten as a while statement

 2007 Pearson Education, Inc. All rights reserved.