PEMROGRAMAN TERSTRUKTUR S1 Teknik Elektro

1
OUTLINE
Pemrograman Terstruktur (Structured programming)
Struktur kendali pengulangan (Repetition control structure)
 for
 do..while

Struktur seleksi (Selection structure)

 switch
 break dan continue

2
STRUKTUR PENGULANGAN
Programmer specifies an action to be repeated while some condition remains true
Additional repetition control structures beside while
 for
 do…while (equal to repeat…until)

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

4
COUNTER-CONTROLLED REPETITION

Counter-controlled repetition requires

1. The name of a control variable (or loop counter)
2. The initial value of the control variable
3. An increment (or decrement) by which the control variable is modified each time through the loop
4. A condition that tests for the final value of the control variable (i.e., whether looping should
continue)

5
COUNTER-CONTROLLED REPETITION USING WHILE

 Format for while repetiotion

initialization;
while ( loopContinuationTest ) {
statement;
increment;
}

Example:
int counter = 1; // control variable & initialization
while ( counter <= 10 ) { // repetition condition
printf( "%d\n", counter );
++counter; // increment
}

6
1 /* Fig. 4.1: fig04_01.c
2 Counter-controlled repetition */ Outline
3 #include <stdio.h>
4
5 /* function main begins program execution */
fig04_01.c
6 int main( void )
7 {
Definition and assignment are
8 int counter = 1; /* initialization */
9
performed 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
7
Condensed code
 C Programmers would make the program more concise
 Initialize counter to 0
 while ( ++counter <= 10 )
printf( “%d\n, counter );

8
COUNTER-CONTROLLED REPETITION USING FOR

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

9
FIG. 4.3 | FOR STATEMENT HEADER COMPONENTS

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

11
FOR REPETITION STATEMENT
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 );

12
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

13
FIG. 4.4 | FLOWCHARTING A TYPICAL FOR REPETITION STATEMENT.

14
1 /* Fig. 4.5: fig04_05.c
2
3
Summation with for */
#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 ) {
sum += number; /* add number to sum */
12
Note that number has a different
13 } /* end for */
14 value each time this statement is
15 printf( "Sum is %d\n", sum ); /* output sum */ executed
16
17 return 0; /* indicate program ended successfully */
18
19 } /* end function main */

Sum is 2550

15
1 /* Fig. 4.6: fig04_06.c
2
3
Calculating compound interest */
#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
22 the first argument raised to the power
23 /* output one table row */
of 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 */

16
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

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

18
DO…WHILE REPETITION STATEMENT
Example (letting counter = 1):
do {
printf( "%d ", counter );
} while (++counter <= 10);
 Prints the integers from 1 to 10

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

1 2 3 4 5 6 7 8 9 10

20
FIG. 4.10 | FLOWCHARTING THE DO...WHILE REPETITION
STATEMENT.

21
SELECTION STATEMENT
22
SELECTION STATEMENT USING SWITCH
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
break;
case '2':
actions
break;
default:
actions
}

 break; exits from statement

23
1 /* Fig. 4.7: fig04_07.c
2 Counting letter grades */ Outline
3 #include <stdio.h>
4
5 /* function main begins program execution */
6 int main( void ) fig04_07.c
7 {
8 int grade; /* one grade */ (1 of 4 )
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 */ EOF stands for “end of file;” this character
13 int fCount = 0; /* number of Fs */
varies from system to system
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 ) {
switch statement checks each of its
20
nested cases for a match
21 /* determine which grade was input */
22 switch ( grade ) { /* switch nested in while */
23
24 case 'A': /* grade was uppercase A */ break statement
25 case 'a': /* or lowercase a */ makes program skip
26 ++aCount; /* increment aCount */ to end of switch
27 break; /* necessary to exit switch */
28 24
29 case 'B': /* grade was uppercase B */
Outline
30 case 'b': /* or lowercase b */
31 ++bCount; /* increment bCount */
32 break; /* exit switch */
33 fig04_07.c
34 case 'C': /* grade was uppercase C */
35 case 'c': /* or lowercase c */
(2 of 4 )
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': /* ignore newlines, */
50 case '\t': /* tabs, */
51 case ' ': /* and spaces in input */
52 break; /* exit switch */
53
25
54 default: /* catch all other characters */
55 printf( "Incorrect letter grade entered." ); Outline
56 printf( " Enter a new grade.\n" );
57 break; /* optional; will exit switch anyway */
58 } /* end switch */ fig04_07.c
59
60 } /* end while */ (3 of 4 )
61 default case occurs
62 /* output summary of results */ if none of the cases
63 printf( "\nTotals for each letter grade are:\n" ); are matched
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 */

26
Enter the letter grades.
Enter the EOF character to end input.
Outline
a
b
c
C fig04_07.c
A
d
f (4 of 4 )
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

27
FIG. 4.8 | SWITCH MULTIPLE-SELECTION STATEMENT WITH BREAKS.

28
SWITCH VS IF
prinsip sama dengan if (lebih umum)
hanya digunakan untuk pemeriksaan
berdasarkan 1 variabel (if sembarang)
digunakan untuk memeriksa harga variabel
terhadap sekumpulan nilai (kalau sedikit →
if)

29
BREAK AND CONTINUE STATEMENT
30
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

31
1 /* Fig. 4.11: fig04_11.c
2
3
Using the break statement in a for statement */
#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
16 } /* end if */
17
loop
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

32
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

33
1 /* Fig. 4.12: fig04_12.c
2
3
Using the continue statement in a for statement */
#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 */
17 loop and performs next iteration
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

34
SUMMARY

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

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
 Stacking
 Any selection can be rewritten as an if statement, and any repetition can be rewritten as a while
statement

35
LATIHAN
Buatlah program untuk mengkonversi suhu dengan pengulangan dan pencabangan
 Pengulangan sampai EOF
 Pencabangan untuk input dalam C, R, K, F

Program harus sudah memasukkan unsur user friendly

36
ANY QUESTIONS?