control structures
control structures
Program Control
The If Statement
• Syntax: if (expression) statement;
• If the expression is true , the statement is
executed. If the expression is false, it is not
executed.
• You can group multiple expressions together with
braces:
if (expression) {
statement 1;
statement 2;
statement 3;
}
The If/Else Statement
• Syntax:
if (expression)
statement_1;
else
statement_2;
• If the expression is true, statement_1 will be
executed, otherwise, statement_2 will be.
if (myVal < 3)
printf(“myVal is less than 3.\n”);
else
printf(“myVal is greater than or equal to 3.\n”);
4
The switch Multiple-Selection
Structure
• 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 structure
5
The switch Multiple-Selection
Structure
• Flowchart of the switch structure
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. 4.7: fig04_07.c
6
2 Counting letter grades */
3 #include <stdio.h>
9 dCount = 0, fCount = 0;
2. Input data
10
13
loop to update
14 while ( ( grade = getchar() ) != EOF ) {
count
15
17
19 ++aCount; /* or lowercase a */
20 break;
21
23 ++bCount; /* or lowercase b */
24 break;
25
27 ++cCount; /* or lowercase c */
28 break;
29
31 ++dCount; /* or lowercase d */
32 break;
33 7
34 case 'F': case 'f': /* grade was uppercase F */
35 ++fCount; /* or lowercase f */
36 break; 2.1 Use switch
37 loop to update
38 case '\n': case' ': /* ignore these in input */ count
39 break;
40 3. Print results
41 default: /* catch all other characters */
42 printf( "Incorrect letter grade entered." );
43 printf( " Enter a new grade.\n" );
44 break;
45 }
46 }
47
48 printf( "\nTotals for each letter grade are:\n" );
49 printf( "A: %d\n", aCount );
50 printf( "B: %d\n", bCount );
51 printf( "C: %d\n", cCount );
52 printf( "D: %d\n", dCount );
53 printf( "F: %d\n", fCount );
54
55 return 0;
56 }
8
Enter the letter grades.
Enter the EOF character to end input.
A
B
Program Output
C
C
A
D
F
C
E
Incorrect letter grade entered. Enter a new grade.
D
A
B
true
condition statement
false
int x = 2;
while (x >= 0){
if ( x == 2){
printf(“Value of x is “, x)
}
x = x – 1;
}
12
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
• Declares it to be an integer
• Reserves space for it in memory
• Sets it to an initial value of 1
13
The do/while Repetition
Structure
• The do/while repetition structure
– 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 );
14
The do/while Repetition
Structure
• Example (letting counter = 1):
do {
printf( "%d ", counter );
} while (++counter <= 10);
– Prints the integers from 1 to 10
15
The do/while Repetition
Structure
• Flowchart of the do/while repetition structure
action(s)
true
condition
false
1 /* Fig. 4.9: fig04_09.c 16
2 Using the do/while repetition structure */
3 #include <stdio.h>
1. Initialize
4 variable
5 int main()
6 { 2. Loop
7 int counter = 1;
3. Print
8
9 do {
12
13 return 0;
14 }
1 2 3 4 5 6 7 8 9 10
Program Output
17
Initialize variable
Condition true
false
20
The for Structure: 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 structure:
– "Increment" may be negative (decrement)
– If the loop continuation condition is initially false
• The body of the for structure is not performed
• Control proceeds with the next statement after the for structure
– Control variable
• Often printed or used inside for body, but not necessary
1 /* Fig. 4.5: fig04_05.c 21
2 Summation with for */
3 #include <stdio.h>
4 1. Initialize
5 int main() variables
6 { 2. for repetition
7 int sum = 0, number; structure
8
9 for ( number = 2; number <= 100; number += 2 )
10 sum += number;
11
12 printf( "Sum is %d\n", sum );
13
14 return 0;
15 }
Sum is 2550
Program Output
22
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
23
The break and continue
Statements
• continue
– Skips the remaining statements in the body of a while,
for or do/while structure
• 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
1 /* Fig. 4.12: fig04_12.c 24
2 Using the continue statement in a for structure */
3 #include <stdio.h>
4 1. Initialize
5 int main() variable
6 {
7 int x;
2. Loop
8
9 for ( x = 1; x <= 10; x++ ) {
10
3. Print
11 if ( x == 5 )
12 continue; /* skip remaining code in loop only
13 if x == 5 */
14
15 printf( "%d ", x );
16 }
17
18 printf( "\nUsed continue to skip printing the value 5\n" );
19 return 0;
20 }
1 2 3 4 6 7 8 9 10
Used continue to skip printing the value 5
Program Output
25
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
26
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
27
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
28
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. 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