0% found this document useful (0 votes)
3 views

control structures

The document provides an overview of control structures in programming, focusing on the if statement, if/else statement, switch statement, and various loop structures (while, do/while, for). It explains the syntax and usage of these structures, including examples for counting letter grades and summing numbers. Additionally, it covers the use of break and continue statements, logical operators, and the importance of structured programming principles.

Uploaded by

mhondiwacraig1
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
3 views

control structures

The document provides an overview of control structures in programming, focusing on the if statement, if/else statement, switch statement, and various loop structures (while, do/while, for). It explains the syntax and usage of these structures, including examples for counting letter grades and summing numbers. Additionally, it covers the use of break and continue statements, logical operators, and the importance of structured programming principles.

Uploaded by

mhondiwacraig1
Copyright
© © All Rights Reserved
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 28

1

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>

5 int main() 1. Initialize


6 { variables
7 int grade;

8 int aCount = 0, bCount = 0, cCount = 0,

9 dCount = 0, fCount = 0;
2. Input data
10

11 printf( "Enter the letter grades.\n" );


2.1 Use switch
12 printf( "Enter the EOF character to end input.\n" );

13
loop to update
14 while ( ( grade = getchar() ) != EOF ) {
count
15

16 switch ( grade ) { /* switch nested in while */

17

18 case 'A': case 'a': /* grade was uppercase A */

19 ++aCount; /* or lowercase a */

20 break;

21

22 case 'B': case 'b': /* grade was uppercase B */

23 ++bCount; /* or lowercase b */

24 break;

25

26 case 'C': case 'c': /* grade was uppercase C */

27 ++cCount; /* or lowercase c */

28 break;

29

30 case 'D': case 'd': /* grade was uppercase D */

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

Totals for each letter grade are:


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

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"
10
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
– A condition that tests for the final value of the control variable (i.e.,
whether looping should continue)
– An increment (or decrement) by which the control variable is
modified each time through the loop
The while Repetition
Structure
• Flowchart of while loop

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 {

10 printf( "%d ", counter );

11 } while ( ++counter <= 10 );

12

13 return 0;

14 }

1 2 3 4 5 6 7 8 9 10
Program Output
17

The for Repetition Structure


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

The for Repetition Structure


• 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 );
Flowchart for for

Initialize variable

Condition true

Test the variable statement


Increment variable

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

You might also like