[go: up one dir, main page]

0% found this document useful (0 votes)
54 views23 pages

C Program Control: Objectives

The document discusses different types of repetition statements in C programming including while, for, and do-while loops. It explains how to use counter-controlled and sentinel-controlled repetition, and provides examples of using for loops to iterate through a set number of repetitions. The key aspects covered are the syntax and flow of each loop type, and how to properly initialize counters, test conditions, and increment/decrement values at each iteration. Examples are given to calculate compound interest over 10 years using a for loop.
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
54 views23 pages

C Program Control: Objectives

The document discusses different types of repetition statements in C programming including while, for, and do-while loops. It explains how to use counter-controlled and sentinel-controlled repetition, and provides examples of using for loops to iterate through a set number of repetitions. The key aspects covered are the syntax and flow of each loop type, and how to properly initialize counters, test conditions, and increment/decrement values at each iteration. Examples are given to calculate compound interest over 10 years using a for loop.
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 23

Chapter 4

C Program Control

Acknowledgment

The notes are adapted from those provided by Deitel & Associates, Inc. and Pearson Education Inc.

OBJECTIVES
In this lecture, you will learn:
 The while, for and do...while repetition statements
to execute statements in a program repeatedly;
 The break and continue program control statements to
alter the flow of program control;
 The switch selection statement;

 The logical operators to form complex conditional


expressions in control statements;
 To avoid confusing the equality and assignment operators

 Structured-Programming Summary

 Review

54
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"

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)

55
Counter-Controlled Repetition
 Example:
int counter = 1; // initialization
while ( counter <= 10 ) { // repetition
condition
di i
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

1 /* Fig. 4.1: fig04_01.c


2 Counter-controlled repetition */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 {
8 int counter = 1; /* initialization */ Definition and assignment are performed
9 simultaneously
10 while
hil ( counter <= 10 ) { /*
/ repetition
i i condition
di i */
/
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

56
Counter-Controlled Repetition
 Condensed code
 C Programmers would make the program more concise

 Initialize
t a e cou te to 0
counter
 while ( ++counter <= 10 )
printf( “%d\n, counter );

Important Notice!
 Controlling counting loops with floating-point variables may
result in imprecise counter values and inaccurate tests for
termination
 Reason: floating-point values may be approximate.

57
1 /* Fig. 4.2: fig04_02.c
2 Counter-controlled repetition with the for statement */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
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 */

The for Repetition Statement

58
The 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 No
semicolon
(;) after last
expression

The for 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 );

59
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
f
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

Notice!
 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.

60
Flowcharting a typical for repetition statement

1 /* Fig. 4.6: fig04_06.c


2 Calculating compound interest */
3 #include <stdio.h>
4 #include <math.h> additional header
5
6 /* function main begins program execution */
7 int main( void )
8 {
9 double amount; /* amount on deposit */
10 double principal = 1000.0; /* starting principal */
11 d bl rate
double t = .05;
05 /* annual
l interest
i t t rate
t */
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; It takes two
24 printf( "%4d%21.2f\n", year, amount ); arguments of type double and returns a
25 } /* end for */ double value.
26
27 return 0; /* indicate program ended successfully */
28
29 } /* end function main */

61
Year Amount on deposit
1 1050.00
2 1102.50
3 1157.63
4 1215.51
5 1276.28
6 1340.10
7 1407 10
1407.10
8 1477.46
9 1551.33
10 1628.89

The do…while Repetition Statement


 The do…while repetition statement
 Similar to the while structure

 Co
Condition
d t o for
o repetition
epet t o tested aafter
te tthee body oof tthee loop
oop iss
performed
 All actions are performed at least once
 Format:
do {
statement;
} while ( condition );

62
The do…while Repetition Statement
 Example (letting counter = 1):
do {
printf( "%d ", counter );
} while
hile (++counter
( co nter <= 10);
10)
 Prints the integers from 1 to 10

Flowchart of the do…while repetition statement

63
1 /* Fig. 4.9: fig04_09.c
2 Using the do/while repetition statement */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
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
less than or equal to 10
14 return 0; /* indicate program ended successfully */
15
16 } /* end function main */

1 2 3 4 5 6 7 8 9 10

The 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

64
1 /* Fig. 4.11: fig04_11.c
2 Using the break statement in a for statement */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
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(
i f( "\nBroke
"\ k out of
f loop
l at x == %d\n",
%d\ " 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

The 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
c e e t expression
e p ess o iss executed,
e ecuted, then
t e the
t e loop-continuation
oop co t uat o
test is evaluated

65
1 /* Fig. 4.12: fig04_12.c
2 Using the continue statement in a for statement */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
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

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
ti
default:
actions
}
 break; exits from statement

66
Flowchart of the switch statement

1 /* Fig. 4.7: fig04_07.c


2 Counting letter grades */
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void )
7 {
8 int grade; /* one grade */
9 int aCount = 0; /* number of As */
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
i h ( grade
d ) { /* switch
i h nested
d in
i while
hil */
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

67
29 case 'B': /* grade was uppercase B */
30 case 'b': /* or lowercase b */
31 ++bCount; /* increment bCount */
32 break; /* exit switch */
33
34 case 'C': /* grade was uppercase C */
35 case 'c': /* or lowercase c */
36 ++cCount; /* increment cCount */
37 break; /* exit switch */
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':
\n : /* ignore newlines,
newlines */
50 case '\t': /* tabs, */
51 case ' ': /* and spaces in input */
52 break; /* exit switch */
53

54 default: /* catch all other characters */


55 printf( "Incorrect letter grade entered." );
56 printf( " Enter a new grade.\n" );
57 break; /* optional; will exit switch anyway */ default case occurs if none of the
58 } /* end switch */ cases are matched
59
60 } /* end while */
61
62 /* output summary of results */
63 printf( "\nTotals for each letter grade are
are:\n"
\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 */

68
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
^Z

Totals for each letter grade are:


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

Logical Operators
 && ( logical AND )
 Returns true if both conditions are true
 || ( logical
og ca OR
O )
 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

69
Logical Operators
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.
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.

expression !expression

0 1
nonzero 0

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

Operator Precedence and Associativity


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

70
Confusing Equality (==) and Assignment (=) Operators

 Dangerous error
 Does not ordinarily cause syntax errors

 Anyy eexpression
p ess o tthat
at pproduces
oduces a va
value
ue can
ca be used in control
co t o
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

Confusing Equality (==) and Assignment (=) Operators

 Example, replacing == with =:


if ( payCode = 4 )
printf( "You get a bonus!\n" );
 This
hi sets payCode d to 4
 4 is nonzero, so expression is true, and bonus awarded no
matter what the payCode was
 Logic error, not a syntax error

71
Confusing Equality (==) and Assignment (=) Operators

 lvalues
 Expressions that can appear on the left side of an equation

 Their
e values
va ues ca
can be changed,
c a ged, such
suc as variable
va ab e names
a es
 x = 4;
 rvalues
 Expressions that can only appear on the right side of an
equation
 Constants, such as numbers

 Cannot write
C i 4 = x;
 Must write x = 4;
 lvalues can be used as rvalues, but not vice versa
 y = x;

Structured-Programming Summary

72
Structured-Programming Summary
 Structured programming
 Easier than unstructured programs to understand, test,
debug and, modify programs
 Rules for structured programming
 Rules developed by programming community

 Only single-entry/single-exit control structures are used

 Rules:

1. Begin with the “simplest flowchart”


2. Stacking rule: Any rectangle (action) can be replaced by two
rectangles
l (actions)
( i ) in i sequence
3. Nesting rule: 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

Structured-Programming Summary
Rule 2 - Any rectangle can be
Rule 1 - Begin with the
replaced by two rectangles in
simplest flowchart
sequence

73
Structured-Programming Summary
Rule 3 - Replace any rectangle with a control structure

Stacked, nested and overlapped building blocks

74
An unstructured flowchart

Structured-Programming Summary
 All programs can be broken down into 3 controls
 Sequence – handled automatically by compiler

 Se
Selection
ect o – if, if…e se o
else or s
switch
tc
 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

75
Review
 Counter-controlled and sentinel-controlled repetitions.
 The for repetition statement handles all details of counter-
controlled repetition.
 In most cases, for repetition statement can be represented
with an equivalent while repetition statement.
 Initialization, loop-continuation condition and increment (or
decrement).
 Data type double is a floating-point type much like float.
 The conversion specifier %21.2f
%21 2f denotes that a floating-point
floating point
value will be displayed right 21 characters with two digits to
the right of the decimal point.
 break and continue statements.

Review
 switch multiple selection statement.
 do…while repetition statement.
 Logical
og ca operators
ope ato s && || !
 Equality operator == and assignment operator =

76

You might also like