C Program Control

CProg1-121 Computer Programming 1

Mr. Exander T. Barrios, MIM, MIT

UIC - ITE Instructor AY 2011 - 2012

Learning Objectives
To be able to use the for, while, and dowhile repetition statements. To understand multiple selection using the switch selection statement. To be able to use the break and continue program control statements To be able to use the logical operators.

Outline
o Introduction o The Essentials of Repetition o Counter-Controlled Repetition o The for Repetition Statement o The for Statement: Notes and Observations o Examples Using the for Statement o The switch Multiple-Selection Statement o The dowhile Repetition Statement o The break and continue Statements o Logical Operators o Confusing Equality (==) and Assignment (=) Operators o Structured Programming Summary
3

Introduction
Additional repetition control structures
while (previous lesson)
 for  Dowhile

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
4

FUNDAMENTALS OF PROGRAMMING (Review) http://www.cprogramming.com/

 Repetition Statements/Loops Loops are used to repeat a block of code. Being able to have your program repeatedly execute a block of code is one of the most basic but useful tasks in programming Loops in C:
a. For b. While c. Do while
5

The Essentials of Repetition

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

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 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)

Essentials of 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
8

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

/* Fig. 4.1: fig04_01.c Counter-controlled repetition */ #include <stdio.h>

/* function main begins program execution */ int main() { int counter = 1; while ( counter <= 10 ) { ++counter; } /* end while */ /* initialization */

/* repetition condition */

printf ( "%d\n", counter ); /* display counter */ /* increment */

return 0; /* indicate program ended successfully */ } /* end function main */

1 2 3 4 5 6 7 8 9 10

For the sample program, add conio.h and change the return 0 into getch().

fig04_01.c

FUNDAMENTALS OF PROGRAMMING (Review)

Increment and Decrement Operators Increasing an integer variable by 1 is a common process. Some people write statements like x+=1; or even worse, x=x+1; There is an easier way: x++; (POST-INCREMENT) Alternatively, you can use ++x; (PRE-INCREMENT)
10 http://irc.essex.ac.uk/www.iota-six.co.uk/c/b4_arithmetic_operators.asp

FUNDAMENTALS OF PROGRAMMING (Review)

 Increment and Decrement Operators
 So what's the difference? They both increase x by 1 (note that x MUST be an integer), and tend to use post-increment. They differ when it comes to statements like these: y = x++; y = ++x;  If x was 5, y = x++; would assign x to y, THEN increase x by 1. The end result is that y equals 5 and x equals 6.  If x was 5, y = ++x; would increase x by 1, THEN assign x to y. The end result is that y equals 6 and x equals 6. As their names suggest, post-incrementing is done AFTER the assignment, pre-incrementing is done BEFORE the assignment. Similar rules apply for decrementing. If you wanted to decrease x by 1, you're free to write x--; (POST-DECREMENT) or --x; (PREDECREMENT), as opposed to: x-=1; or x=x-1;
11

http://irc.essex.ac.uk/www.iota-six.co.uk/c/b4_arithmetic_operators.asp

Essentials of Counter-Controlled Repetition

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

12

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() 7 { 8 9 10 11 12 13 14 15 16 17 18 } /* end function main */
For the sample program, add conio.h and change the return 0 into getch().

int counter; /* define counter */

/* initialization, repetition condition, and increment are all included in the for statement header. */ for ( counter = 1; counter <= 10; counter++ ) { printf( "%d\n", counter ); } /* end for */

return 0; /* indicate program ended successfully */

fig04_02.c

The for Repetition Statement

14

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

15

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

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 )

17

The for Statement : Notes and Observations

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
18

The for Statement : Notes and Observations

Establish initial value of control variable counter counter = 1 1

counter <= 10

true

printf( "%d", counter );

counter++ Increment the control variable

Determine if final value of control variable has been reached

false

Body of loop (this may be many statements)

19

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

/* Fig. 4.5: fig04_05.c Summation with for */ #include <stdio.h> /* function main begins program execution */ int main() { int sum = 0; /* initialize sum */ int number; /* number to be added to sum */

fig04_05.c

for ( number = 2; number <= 100; number += 2 ) { sum += number; /* add number to sum */ } /* end for */ printf( "Sum is %d\n", sum ); /* output sum */ return 0; /* indicate program ended successfully */

19 } /* end function main */

Sum is 2550

Program Output

For the sample program, add conio.h and change the return 0 into getch().

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26

/* Fig. 4.6: fig04_06.c Calculating compound interest */ #include <stdio.h> #include <math.h>

fig04_06.c (Part 1 of 2)

/* function main begins program execution */ int main() { double amount; double rate = .05; int year; /* amount on deposit */ /* interest rate */ /* year counter */ double principal = 1000.0; /* starting principal */

/* output table column head */ printf( "%4s%21s\n", "Year", "Amount on deposit" );

/* calculate amount on deposit for each of ten years */ for ( year = 1; year <= 10; year++ ) { /* calculate new amount for specified year */ amount = principal * pow( 1.0 + rate, year ); /* output one table row */ printf( "%4d%21.2f\n", year, amount ); } /* end for */

For the sample program, add conio.h and change the return 0 into getch().

27 28

return 0; /* indicate program ended successfully */

29 } /* end function main */

fig04_06.c (Part 2 of 2)

Year 1 2 3 4 5 6 7 8 9 10

Amount on deposit 1050.00 1102.50 1157.63 1215.51 1276.28 1340.10 1407.10 1477.46 1551.33 1628.89

Program Output

For the sample program, add conio.h and change the return 0 into getch().

FUNDAMENTALS OF PROGRAMMING (Review) http://www.cprogramming.com/

 For loop Details The variable initialization allows you to either declare a variable and give it a value or give a value to an already existing variable. Second, the condition tells the program that while the conditional expression is true the loop should continue to repeat itself. The variable update section is the easiest way for a for loop to handle changing of the variable.
23

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

24

The switch Multiple-Selection Statement

Flowchart of the switch statement
case a false true true case a action(s) break

case b false . . .

case b action(s)

break

case z false default action(s)

true

case z action(s)

break

25

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28

/* Fig. 4.7: fig04_07.c Counting letter grades */ #include <stdio.h> /* function main begins program execution */ int main() { int grade; /* one grade */ int aCount = 0; /* number of As */ int bCount = 0; /* number of Bs */ int cCount = 0; /* number of Cs */ int dCount = 0; /* number of Ds */ int fCount = 0; /* number of Fs */ printf( printf( "Enter the letter grades.\n" ); );

fig04_07.c (Part 1 of 3)

"Enter the EOF character to end input.\n"

/* loop until user types end-of-file key sequence */ while ( ( grade = getchar() ) != EOF ) { /* determine which grade was input */ switch ( grade ) { /* switch nested in while */ case 'A': case 'a': break; /* grade was uppercase A */ /* or lowercase a */ /* necessary to exit switch */

++aCount; /* increment aCount */

For the sample program, add conio.h and change the return 0 into getch().

29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53

case 'B': case 'b':

/* grade was uppercase B */ /* or lowercase b */

++bCount; /* increment bCount */ break; /* exit switch */

case 'C': case 'c':

/* grade was uppercase C */ /* or lowercase c */

fig04_07.c (Part 2 of 3)

++cCount; /* increment cCount */ break; /* exit switch */

case 'D': case 'd':

/* grade was uppercase D */ /* or lowercase d */

++dCount; /* increment dCount */ break; /* exit switch */

case 'F': case 'f':

/* grade was uppercase F */ /* or lowercase f */

++fCount; /* increment fCount */ break; /* exit switch */

case '\n': case '\t': case ' ': break;

/* ignore newlines, */ /* tabs, */ /* and spaces in input */ /* exit switch */

For the sample program, add conio.h and change the return 0 into getch().

54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71

default:

/* catch all other characters */

printf( "Incorrect letter grade entered." ); printf( " Enter a new grade.\n" ); break; /* optional; will exit switch anyway */

} /* end switch */

} /* end while */

fig04_07.c (Part 3 of 3)

/* output summary of results */ printf( "\nTotals for each letter grade are:\n" ); printf( "A: %d\n", aCount ); /* display number of A grades */ printf( "B: %d\n", bCount ); /* display number of B grades */ printf( "C: %d\n", cCount ); /* display number of C grades */ printf( "D: %d\n", dCount ); /* display number of D grades */ printf( "F: %d\n", fCount ); /* display number of F grades */

return 0; /* indicate program ended successfully */

72 } /* end function main */

For the sample program, add conio.h and change the return 0 into getch().

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

Program Output

The while Repetition Statement

The while repetition statement
Format:

counter while (condition) { statement; }

30

FUNDAMENTALS OF PROGRAMMING (Review) http://www.cprogramming.com/

While loop Details

The true represents a boolean expression which could be x == 1 or while ( x != 7 ) (x does not equal 7). It can be any combination of boolean statements that are legal. Even, (while x ==5 || v == 7) which says execute the code while x equals five or while v equals 7. Notice that a while loop is the same as a for loop without the initialization and update sections. However, an empty condition is not legal for a while loop as it is with a for loop.
31

The dowhile Repetition Statement

The dowhile repetition statement
Similar to the while structure Condition for repetition tested after the body of the loop is performed
All actions are performed at least once

Format:

do { statement; } while ( condition );

32

The dowhile Repetition Statement

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

33

The dowhile Repetition Statement

Flowchart of the dowhile repetition statement
action(s)

true condition false

34

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() 7 { 8 9 10 11 12 13 14 15 16 } /* end function main */ return 0; /* indicate program ended successfully */ do { printf( "%d ", counter ); /* display counter */ } while ( ++counter <= 10 ); /* end do...while */ int counter = 1; /* initialize counter */

fig04_09.c

10

Program Output

For the sample program, add conio.h and change the return 0 into getch().

FUNDAMENTALS OF PROGRAMMING (Review) http://www.cprogramming.com/

 Do while Details Notice that the condition is tested at the end of the block instead of the beginning, so the block will be executed at least once. If the condition is true, we jump back to the beginning of the block and execute it again. A do..while loop is basically a reversed while loop. A while loop says "Loop while the condition is true, and execute this block of code", a do..while loop says "Execute this block of code, and loop while the condition is true".

36

The break and continue Statements

 break
Causes immediate exit from a while, for, dowhile 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
37

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

/* Fig. 4.11: fig04_11.c Using the break statement in a for statement */ #include <stdio.h>

/* function main begins program execution */ int main() { int x; /* counter */

fig04_11.c

/* loop 10 times */ for ( x = 1; x <= 10; x++ ) { /* if x is 5, terminate loop */ if ( x == 5 ) { break; /* break loop only if x is 5 */ } /* end if */

printf( "%d ", x ); /* display value of x */ } /* end for */

printf( "\nBroke out of loop at x == %d\n", x );

return 0; /* indicate program ended successfully */

25 } /* end function main */

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

Program Output

For the sample program, add conio.h and change the return 0 into getch().

The break and continue Statements

 continue
Skips the remaining statements in the body of a while, for or dowhile statement
Proceeds with the next iteration of the loop

while and dowhile

Loop-continuation test is evaluated immediately after the continue statement is executed

for
Increment expression is executed, then the loopcontinuation test is evaluated
39

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

/* Fig. 4.12: fig04_12.c Using the continue statement in a for statement */ #include <stdio.h>

/* function main begins program execution */ int main() { int x; /* counter */

fig04_12.c

/* loop 10 times */ for ( x = 1; x <= 10; x++ ) { /* if x is 5, continue with next iteration of loop */ if ( x == 5 ) { continue; /* skip remaining code in loop body */ } /* end if */

printf( "%d ", x ); /* display value of x */ } /* end for */

printf( "\nUsed continue to skip printing the value 5\n" ); return 0; /* indicate program ended successfully */

25 } /* end function main */

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

Program Output

For the sample program, add conio.h and change the return 0 into getch().

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
true && false true || false !false

Result
false true true
41

Logical Operators
expression1
0 0 nonzero nonzero

expression2
0 nonzero 0 nonzero

expression1 && expression2

0 0 0 1

Fig. 4.13

Truth table for the && (logical AND) operator.

expression1
0 0 nonzero nonzero

expression2
0 nonzero 0 nonzero

expression1 || expression2
0 1 1 1

Fig. 4.14

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

expression
0 nonzero

! expression
1 0

Fig. 4.15

Truth table for operator ! (logical negation).

42

Logical Operators
Operators
++ * + < == && || ?: = , += -= *= /= %= -/ <= != > >= + % ! (type)

Associativity
right to left left to right left to right left to right left to right left to right left to right right to left right to left left to right

Type
unary multiplicative additive relational equality logical AND logical OR conditional assignment comma

Fig. 4.16

Operator precedence and associativity.

43

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

44

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
45

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;
46

Structured-Programming Summary
Selection

if statement
(single selection) T F F

ifelse statement
(double selection) T

switch statement
(multiple selection) T F T F . . . T F
break break

break

47

Structured-Programming Summary
Repetition

while statement

do while statement

for statement

T F
F T
F T

48

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

49

Structured-Programming Summary
Rules: 1.Begin with the simplest flowchart 2.Stacking rule: Any rectangle (action) can be replaced by two rectangles (actions) in sequence 3.Nesting rule: Any rectangle (action) can be replaced by any control structure (sequence, if, ifelse, switch, while, dowhile or for) 4.Rules 2 and 3 can be applied in any order and multiple times

50

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

Rule 2

Rule 2

Rule 2

. . .

51

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

Rule 3 Rule 3

52

Structured-Programming Summary
St ac ke d b uilding b lo c ks Nested build ing bloc ks

O v erla pping b uilding bloc ks (Illega l in struc tured pro gra ms)

53

Structured-Programming Summary

Figure 4.23 An unstructured flowchart.

54

Structured-Programming Summary
All programs can be broken down into 3 controls
Sequence handled automatically by compiler Selection if, ifelse or switch Repetition while, dowhile 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
55

Machine Problems

Exercise Numbers 4.9 4.10 4.11 4.12 4.13

Exercise Numbers 4.16 4.18 4.28 4.31 4.33

56

C Program Control
CProg1-121 Computer Programming 1

The End.

Up Next: Functions