Bab. 3 Kendali Program
Tujuan
Instruksional
|
|
·
Repetisi
terkendali-kounter.
·
Statemen repetisi for.
·
Contoh penggunaan statemen for.
·
Statemen
seleksi-jamak switch.
|
·
Statemen repetisi do...while.
·
Statemen continue dan break.
·
Operator logikal.
|
3.1 Introduksi
Sekarang Anda seharusnya sudah mulai
nyaman dalam menulis program C sederhana. Pada bab ini, repetisi atau
perulangan akan didiskusikan secara menyeluruh dan detil. Statemen repetisi for dan do...while akan disajikan.
Statemen seleksi-jamak switch akan
dikenalkan. Statemen break juga akan
didiskusikan, yang berguna untuk keluar secara mendadak dari statemen kendali
tertentu, dan statemen continue untuk melompati
sisa tubuh dari suatu statemen kendali dan melanjutkan iterasi berikutnya pada
loop. Pada bab ini juga akan
didiskusikan mengenai operator logikal yang dipakai untuk menggabungkan
beberapa kondisi.
3.2 Esensi Repetisi
Kebanyakan program melibatkan repetisi,
atau looping, atau perulangan. Loop merupakan sebuah kelompok instruksi
komputer yang dieksekusi secara berulang ketika kondisi kontinuasi-loop
bernilai true. Telah didiskusikan dua cara repetisi:
1.
Repetisi terkendali-kounter.
2. Repetisi
terkendali-sentinel.
Repetisi terkendali-kounter kadangkala
dikenal dengan repetisi pasti karena Anda telah mengetahui sebelumnya secara
persis tentang berapa kali loop akan dieksekusi. Repetisi terkendali-sentinel
kadangkala dikenal dengan repetisi tak-pasti karena Anda tidak mengetahui
secara persis sebelumnya tentang berapa kali loop akan dieksekusi.
Dalam repetisi terkendali-kounter,
variabel kontrol atau variabel kendali digunakan untuk menghitung jumlah
repetisi. Variabel kontrol diinkremen (biasanya sebesar 1) setiap kali kelompok
instruksi dieksekusi. Ketika nilai variabel kontrol mengindikasikan bahwa
jumlah repetisi yang sesuai telah dilakukan, loop akan berhenti dan komputer
akan melanjutkan eksekusi terhadap statemen setelah statemen repetisi.
Nilai sentinel digunakan untuk
mengendalikan repetisi ketika:
1.
Jumlah persis dari repetisi tidak diketahui
sebelumnya, dan
2. Loop
menyertakan statemen yang memperoleh data setiap kali loop diiterasi.
Nilai sentinel mengindikasikan “akhir
dari data”. Sentinel dientrikan setelah semua item data reguler disuplai kepada
program. Sentinel harus berbeda dari item data reguler.
3.3 Repetisi Terkendali-Kounter
Repetisi terkendali-kounter memerlukan:
1.
Nama suatu variabel kontrol (kounter loop).
2.
Nilai awal dari variabel kontrol.
3.
Inkremen (atau dekremen) untuk memodifikasi variabel
kontrol pada tiap iterasi loop.
4. Kondisi yang
menguji nilai akhir dari variabel kontrol (apakah loop akan berlanjut atau
tidak).
Perhatikan program sederhana yang ditunjukkan pada Gambar 3.1, yang
menampilkan angka-angka dari 1 sampai 10. Definisi
int kounter = 1; /* inisialisasi */
memberikan variabel kontrol (kontrol), mendefinisikannya menjadi sebuah
integer, dan mengalokasikan ruang memori untuknya, dan menetapkannya dengan
nilai awal 1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
/* Gambar 3.1: gambar03_01.c
Repetisi terkendali-kounter */
#include <stdio.h>
/* fungsi main memulai eksekusi program */
int main( void )
{
int kounter = 1; /* inisialisasi
*/
while (kounter
<= 10) { /* kondisi repetisi */
printf ( "%d\n", kounter ); /* menampilkan kounter */
++kounter; /* inkremen */
} /*
akhir while */
return
0; /* mengindikasikan bahwa program berhenti dengan sukses */
} /* akhir fungsi main */
|
1
2
3
4
5
6
7
8
9
10
Gambar 3.1 | Repetisi
terkendali-kounter
Definisi dan inisialisasi kounter dapat pula dituliskan sebagai
int kounter;
kounter = 1;
Definisi tersebut tidak dapat
dieksekusi, statemen penugasan yang dapat dieksekusi. Pada buku ini, kedua
metode penginisialisasian variabel digunakan. Statemen
++kounter; /* inkremen */
menginkremen kounter loop sebesar 1
setiap kali loop dieksekusi. Kondisi kontinuasi-loop dalam statemen while dipakai untuk menguji manakala nilai variabel kontrol
kurang dari atau sama dengan 10. Tubuh while ini dieksekusi bahkan ketika variabel kontrol bernilai 10. Loop berhenti
ketika variabel kontrol melebihi 10 (misalnya, kounter menjadi 11).
Anda dapat membuat program pada Gambar
3.1 menjadi lebih pendek atau singkat dengan cara menginisialisasi kounter menjadi 0 dan mengganti statemen while dengan
while ( ++kounter <= 10 )
printf( "%d\n", kounter );
Kode tersebut menghemat satu statemen
karena penginkremenan dilakukan secara langsung di dalam statemen while sebelum kondisi diuji. Di samping itu, kode ini
mengeliminasi kebutuhan akan kurung kurawal yang mengapit tubuh while karena
while sekarang hanya memuat satu statemen. Pengkodean padat semacam ini
memerlukan banyak latihan. Beberapa programer merasa bahwa pengkodean semacam
ini terlalu rumit dan gampang menimbulkan kebingungan, sehingga mereka
menghindarinya.
3.4 Statemen Repetisi for
Statemen repetisi for menangani dan mengatasi semua detil repetisi
terkendali-kounter. Untuk mengilustrasikan keunggulannya, program pada Gambar
3.1 akan dikode ulang. Hasilnya ditunjukkan pada Gambar 3.2.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/* Gambar 3.2: gambar03_02.c
Repetisi terkendali-kounter dengan statemen for */
#include <stdio.h>
/* fungsi main memulai eksekusi program */
int main( void )
{
int
kounter; /* mendefenisikan kounter */
/*
inisialisasi, kondisi repetisi, dan inkremen
semua disertakan di dalam header statemen for. */
for ( kounter = 1; kounter <=
10; kounter++ ) {
printf ( "%d\n", kounter ); /* menampilkan kounter */
} /*
akhir while */
return
0; /* mengindikasikan bahwa program berhenti dengan sukses */
} /* akhir fungsi main */
|
Gambar 3.2 | Repetisi
terkendali-kounter dengan statemen for
Program beroperasi sebagai berikut.
Ketika statemen for mulai
dieksekusi, variabel kontrol kounter diinisialisasi
dengan 1. Kemudian, kondisi kontinuasi-loop kounter <= 10 diperiksa. Karena nilai awal kounter adalah 1, kondisi ini terpenuhi, jadi statemen printf (baris 13) menampilkan nilai kounter, yaitu 1. Variabel kontrol kounter kemudian diinkremen dengan ekspresi kounter++, dan loop kembali lagi dengan
pengujian kontinuasi-loop. Karena variabel kontrol sekarang bernilai 2, nilai
akhir tidak terlampaui, jadi program mengeksekusi statemen printf kembali. Proses ini berlanjut sampai
variabel kontrol kounter diinkremen menjadi nilai akhirnya 11, ini menyebabkan
pengujian kontinuasi-loop kounter <= 10 tidak terpenuhi, dan repetisi berhenti. Program berlanjut mengeksekusi
statemen pertama setelah statemen for (pada kasus
ini, statemen return pada akhir
program).
Gambar 3.3 menyajikan penjelasan lebih
dekat atas statemen for pada Gambar
3.2. Perhatikan bahwa statemen for “melakukan
semuanya”, yaitu menspesifikasi setiap item yang dibutuhkan untuk repetisi
terkendali-kounter. Jika terdapat lebih dari satu statemen di dalam tubuh for, maka sepasang kurung kurawal diperlukan untuk
mendefinisikan tubuh loop.
Gambar 3.3 | Komponen-komponen di dalam header statemen
for
Perhatikan bahwa Gambar 3.2 menggunakan
kondisi kontinuasi-loop kounter <= 10. Jika Anda secara tidak tepat menuliskan kounter < 10, maka loop akan
dieksekusi hanya 9 kali. Ini merupakan kesalahan yang umum terjadi dan dikenal
dengan error off-by-one.
Format umum untuk statemen for adalah
for
( ekspresi1; ekspresi2; ekspresi3)
statemen
dimana ekspresi1 menginisialisasi variabel kontrol loop, ekspresi2 adalah kondisi kontinuasi-loop, dan ekspresi3 menginkremen variabel kontrol. Pada kebanyakan kasus, statemen for dapat
direpresentasikan dengan statemen while ekivalen
sebagai berikut:
ekspresi1;
while
(ekspresi2) {
statemen
ekspresi3;
}
Terdapat satu pengecualian terhadap
aturan ini, dimana akan didiskusikan pada Bagian 3.9.
Seringkali, ekspresi1 dan ekspresi3 adalah daftar ekspresi yang dipisahkan
koma. Koma yang digunakan di sini sebenarnya adalah operator koma yang menjamin
bahwa ekspresi-ekspresi tersebut dievaluasi dari kiri ke kanan.
Tiga ekspresi di dalam statemen for bersifat opsional. Jika ekspresi2 diabaikan, maka C mengasumsikan bahwa kondisi tersebut bernilai true, jadi menyebabkan loop tidak akan pernah berhenti. Anda
juga dapat mengabaikan ekspresi1 jika variabel
kontrol diinisialisasi di tempat lain di dalam program. Anda juga dapat
mengabaikan ekspresi3 jika inkremen
dilakukan di dalam tubuh statemen for atau jika inkremen tidak diperlukan.
Ekspresi inkremen di dalam statemen for berperan
seperti statemen C yang berdiri sendiri di akhir tubuh loop for. Oleh karena itu, ekspresi
kounter = kounter + 1
kounter += 1
++kounter
kounter++
semuanya ekivalen di dalam bagian
inkremen dari statemen for. Banyak
programer C lebih memilih bentuk kounter++ karena penginkremenan terjadi
setelah tubuh loop dieksekusi.
3.5 Statemen for: Catatan dan Observasi
1. Inisialisasi,
kondisi kontinuasi-loop dan inkremen dapat memuat ekspresi aritmatik. Sebagai
contoh, jika x = 2 dan y = 10, maka statemen
for ( j = x; j <= 4 * x * y; j += y / x )
ekivalen dengan statemen
for ( j = 2; j <= 80; j += 5 )
2.
Inkremen bisa bernilai negatif (dimana pada kasus
tersebut hal itu sama dengan dekremen dan loop melakukan penghitungan mundur).
3.
Jika kondisi kontinuasi-loop awalnya bernilai false, maka tubuh
loop tidak dieksekusi. Program akan melanjutkan eksekusi terhadap statemen
setelah statemen for.
4.
Variabel kontrol seringkali ditampilkan atau
digunakan dalam perhitungan di dalam tubuh suatu loop. Sangat umum pula
dijumpai variabel kontrol yang digunakan untuk mengendalikan repetisi tanpa
melibatkannya di dalam tubuh loop.
5.
Statemen for sangat mirip
dengan statemen while. Misalnya,
Gambar 3.4 menunjukkan grafik-alir dari statemen for
for ( kounter = 1; kounter <= 10; kounter++ )
printf( "%d", kounter );
Grafik-alir membuat lebih jelas bahwa inisialisasi terjadi
hanya sekali dan penginkremenan terjadi setelah statemen di dalam tubuh
dieksekusi.
Gambar 3.4 | Gafik-alir sebuah statemen repetisi for
3.6 Contoh Penggunaan Statemen for
Berikut beberapa contoh yang menunjukkan metode pemodifikasian variabel
kontrol di dalam suatu statemen for.
1. Mengubah
variabel kontrol dari 1 sampai 100 dengan inkremen sebesar 1.
for ( i = 1; i <= 100; i++ )
2. Mengubah
variabel kontrol dari 100 sampai 1 dengan inkremen sebesar -1 (dekremen sebesar
1).
for ( i = 100; i >= 1; i-- )
3. Mengubah
variabel kontrol dari 7 sampai 77 dengan langkah 7:
for ( i = 7; i <= 77; i += 7 )
4. Mengubah
variabel kontrol dari 20 sampai 2 dengan langkah -2.
for ( i = 20; i >= 2; i -= 2 )
5. Mengubah
variabel kontrol menjadi runtun nilai berikut: 2, 5, 8, 11, 14, 17.
for ( j = 2; j <= 17; j += 3 )
6.
Mengubah variabel kontrol menjadi runtun nilai
berikut: 44, 33, 22, 11, 0.
for ( j = 44; j >= 0; j -= 11 )
Dua contoh berikut menyediakan aplikasi
sederhana atas statemen for. Gambar 3.5
menggunakan statemen for untuk
menjumlahkan semua integer genap dari 2 sampai 100.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
/* Gambar 3.5: gambar03_05.c
Penjumlahan dengan for */
#include <stdio.h>
/* fungsi main memulai eksekusi */
int main( void )
{
int jum = 0; /* menginisialisasi
jum */
int
angka; /* angka yang akan dijumlahkan */
for ( angka = 2; angka <= 100;
angka += 2 ) {
jum += angka; /* menambahkan
angka kepada jumlah */
} /*
akhir for */
printf("Jumlah adalah %d\n", jum); /* menampilkan jum */
return
0; /* mengindikasikan bahwa program berhenti dengan sukses */
} /* akhir dari fungsi main */
|
Jumlah adalah 2550
Gambar 3.5 | Penggunaan for untuk menjumlahkan
Tubuh statemen for pada Gambar 3.5 sebenarnya dapat digabungkan menjadi porsi
paling-kanan dari header menggunakan operator koma sebagai berikut:
for ( angka = 2; angka <= 100; jum += angka, angka +=
2 )
; /* statemen kosong */
Inisialisasi jum = 0 juga dapat digabung dengan ke dalam
bagian inisialisasi pada for.
Contoh berikutnya akan menghitung suku
bunga menggunakan statemen for. Perhatikan
simpulan masalah berikut:
Seseorang menginvestasikan Rp. 1000.00 di dalam sebuah akun penyimpanan
dengan suku bunga 5%. Diasumsikan bahwa semua bunga digabungkan dengan modal
investasi di dalam akun, hitunglah dan tampilkanlah jumlah uang di dalam akun
pada tiap akhir tahun selama 10 tahun. Gunakan formula berikut:
dimana
Permasalahan ini melibatkan sebuah loop
yang melakukan perhitungan jumlah uang di dalam akun untuk setiap tahun selama
10 tahun. Solusi ditunjukkan pada Gambar 3.6.
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
|
/* Gambar 3.6: gambar03_06.c
Menghitung suku bunga */
#include <stdio.h>
#include <math.h>
/* fungsi main memulai eksekusi */
int main( void )
{
double
jumlah; /* jumlah uang di deposit */
double
prinsipal = 1000.0; /* investasi awal */
double
suku = .05; /* suku bunga tahunan */
int
tahun; /* kounter tahun */
/* menampilkan kepala kolom tabel */
printf( "%4s%21s\n", "Tahun",
"Jumlah di deposit" );
/* menghitung jumlah uang di deposit setiap
tahun untuk 10 tahun */
for ( tahun = 1; tahun <= 10;
tahun++ ) {
/* menghitung jumlah baru untuk setiap
tahun */
jumlah = prinsipal * pow( 1.0 + suku, tahun );
/* menampilkan satu baris tabel */
printf( "%4d%21.2f\n", tahun,
jumlah );
} /*
akhir for */
return 0; /* mengindikasikan bahwa
program berhenti dengan sukses */
} /* akhir dari fungsi main */
|
Tahun Jumlah di deposit
1 1050.00
2 1102.50
3 1157.63
4 1215.51
5 1276.28
6 1340.10
7 1407.10
8 1477.46
9 1551.33
10 1628.89
Gambar 3.6 | Penghitungan
suku bunga menggunakan statemen for
Program mengeksekusi tubuh statemen for sebanyak 10 kali, memodifikasi variabel kontrol dari 1
sampai 10 dengan inkremen sebesar 1. Meskipun C tidak menyertakan operator
pemangkatan (eksponensiasi), tetapi Anda dapat menggunakan fungsi pustaka
standar pow untuk tujuan ini. Fungsi pow(x,y) menghitung nilai x yang dipangkatkan dengan y. Fungsi ini mengambil dua argumen bertipe double dan menghasilkan nilai balik bertipe double. Tipe double adalah sebuah tipe titik-mengambang yang hampir sama dengan float, tetapi secara umum variabel bertipe double dapat menyimpan suatu nilai yang
mempunyai magnitudo jauh lebih besar dengan kepresisian lebih tinggi daripada
tipe float. Header <math.h> (baris 4) harus disertakan ketika fungsi matematik seperti pow digunakan. Program ini akan mengalami malfungsi tanpa
penyertaan math.h. Fungsi pow memerlukan dua argumen bertipe double, tetapi variabel tahun adalah sebuah integer. File math.h menyertakan informasi yang memberitahu
kompiler untuk mengkonversi nilai tahun menjadi representasi double temporer sebelum memanggil fungsi
tersebut. Informasi ini dimuat di dalam prototipe fungsi pow. Prototipe fungsi dijelaskan pada Bab 4. Perhatikan bahwa
variabel jumlah, prinsipal, dan suku didefinisikan
bertipe double.
Berikut adalah penjelasan sederhana
atas apa yang salah ketika menggunakan float atau double untuk
merepresentasikan jumlah rupiah. Dua jumlah rupiah float yang disimpan sebesar 14.32 (dengan %.2f ditampilkan sebagai 14.23) dan 18.673 (dengan %.2f ditampilkan sebagai 18.67). Ketika kedua dijumlahkan, akan dihasilkan
sebesar 32.907, dimana dengan %.2f akan
ditampilkan sebagai 32.91. Jadi, yang muncul adalah
14.23
+
18.67
-------
32.91
Jelaslah terlihat bahwa penjumlahan
atas angka secara individual menghasilkan 32.90! Hal ini perlu Anda antisipasi.
Penspesifikasi konversi %21.2f digunakan untuk menampilkan nilai
variabel jumlah di dalam program. Angka 21 di dalam
penspesifikasi konversi menandakan lebar bidang dimana di dalamnya nilai akan
ditampilkan. Lebar bidang 21 menspesifikasi bahwa nilai yang akan ditampilkan
akan berada di dalam 21 posisi. Angka 2 menspesifikasi presisi (jumlah posisi
desimal). Jika jumlah karakter yang ditampilkan kurang dari lebar bidang, maka
nilai akan secara otomatis disejajarkan ke kanan di dalam bidang. Hal ini
berguna untuk menyejajarkan nilai pecahan dengan kepresisian yang sama (jadi
titik desimalnya sejajar secara vertikal). Untuk menyejajarkan ke kiri atas
suatu nilai di dalam bidang, Anda bisa menempatkan tanda minus (-) di antara %
dan lebar bidang. Tanda minus juga bisa dipakai untuk menyejajarkan integer
(seperti %-6d) dan pengaturan karakter (seperti %-8s). Kapabilitas
pemformatan printf dan scanf akan didiskusikan pada Bab 8.
3.7 Statemen Seleksi-Jamak switch
Pada Bab 2, telah didiskusikan statemen
seleksi-tunggal if dan statemen
seleksi-ganda if...else. Kadangkala, suatu algoritma memuat
serangkaian keputusan dimana di dalamnya sebuah variabel atau ekspresi diuji
secara terpisah untuk setiap nilai integer konstanta yang diasumsikan, dan
berbagai aksi dipilih. Ini dikenal dengan seleksi jamak. C menyediakan statemen
seleksi-jamak switch untuk menangani
pembuatan keputusan semacam ini. Statemen switch memuat serangkaian label case, sebuah kasus default opsional, dan statemen yang akan
dieksekusi untuk setiap kasus. Gambar 3.7 menggunakan switch untuk menghitung jumlah dari setiap
nilai huruf yang didapatkan mahasiswa dalam sebuah ujian.
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
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
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
|
/* Gambar 3.7: gambar03_07.c
Menghitung nilai huruf */
#include <stdio.h>
/* fungsi main memulai eksekusi program */
int main( void )
{
int
nilai; /* satu nilai */
int
aHitung = 0; /* jumlah A */
int
bHitung = 0; /* jumlah B */
int
cHi.,,tung = 0; /* jumlah C */
int
dHitung = 0; /* jumlah D */
int
fHitung = 0; /* jumlah F */
printf( "Masukkan nilai huruf.\n" );
printf( "Masukkan karakter EOF untuk mengakhiri.\n"
);
/*
loop beriterasi sampai pengguna mengetikka EOF */
while
( (nilai = getchar()) !=
EOF) {
/*
menentukan nilai mana yang dientrikan */
switch ( nilai ) { /* switch
bersarang di dalam while */
case 'A': /* nilai adalah huruf besar A */
case 'a': /* atau huruf kecil a */
++aHitung; /* menginkremen aHitung */
break; /* penting untuk keluar switch */
case 'B': /* nilai adalah
huruf besar B */
case 'b': /* atau huruf kecil b */
++bHitung; /* menginkremen bHitung */
break; /* penting untuk keluar switch */
case 'C': /* nilai adalah
huruf besar C */
case 'c': /* atau huruf kecil c */
++cHitung; /* menginkremen cHitung */
break; /* penting untuk keluar switch */
case 'D': /* nilai adalah
huruf besar D */
case 'd': /* atau huruf kecil d */
++dHitung; /* menginkremen dHitung */
break; /* penting untuk keluar switch */
case 'F': /* nilai adalah
huruf besar F */
case 'f': /* atau huruf kecil f */
++fHitung; /* menginkremen fHitung */
break; /* penting untuk keluar switch */
case
'\n': /* mengabaikan garis-baru, */
case '\t': /* tab, */
case ' ': /* dan spasi dalam masukan
*/
break; /* keluar switch */
default: /* menangkap semua
karakter lain */
printf( "Nilai huruf yang dimasukkan
salah." );
printf( " Masukkan nilai huruf
baru.\n" );
break; /* opsional; akan keluar switch */
}
/* akhir switch */
} /*
akhir while */
/*
menampilkan simpulan hasil */
printf( "\nTotal setiap nilai huruf
adalah:\n" );
printf( "A: %d\n", aHitung
); /* menampilkan jumlah nilai A */
printf( "B: %d\n", bHitung
); /* menampilkan jumlah nilai B */
printf( "C: %d\n", cHitung
); /* menampilkan jumlah nilai C */
printf( "D: %d\n", dHitung
); /* menampilkan jumlah nilai D */
printf( "F: %d\n", fHitung
); /* menampilkan jumlah nilai F */
return
0; /* mengindikasikan bahwa program berhenti dengan sukses */
} /* akhir dari fungsi main */
|
Masukkan nilai huruf.
Masukkan karakter EOF untuk
mengakhiri.
a
b
c
C
A
d
f
C
E
Nilai huruf yang dimasukkan salah.
Masukkan nilai huruf baru.
D
A
b
^Z
Total setiap nilai huruf adalah:
A: 3
B: 2
C: 3
D: 2
F: 1
Gambar 3.7 | Contoh switch
Di dalam program, pengguna memasukkan
huruf nilai untuk suatu kelas. Di dalam header while (baris 19),
while ( ( nilai = getchar() ) != EOF )
penugasan yang diapit kurung (nilai = getchar()) dieksekusi terlebih dahulu. Fungsi getchar (dari <stdio.h>) membaca karakter demi karakter dari papanketik dan
menyimpan karakter tersebut di dalam variabel integer nilai. Karakter biasanya disimpan di dalam variabel bertipe char. Akan tetapi, salah satu fitur penting dari C adalah bahwa
karakter dapat disimpan di sembarang tipe data integer karena karakter umumnya
direpresentasikan sebagai integer satu-byte di dalam komputer. Jadi, Anda dapat
memperlakukan sebuah karakter seperti integer, tergantung kegunaanya. Sebagai
contoh, statemen
printf( "Karakter (%c) memiliki nilai
%d.\n", 'a', 'a' );
menggunakan penspesifikasi konversi %c dan %d untuk
menampilkan karakter a dan nilai
integernya. Hasilnya
Karakter (a) memiliki nilai 97.
Integer 91 merupakan representasi
numerik atas karakter di dalam komputer. Banyak komputer saat ini menggunakan
himpunan karakter ASCII (American
Standard Code for Information Interchange) dimana di dalamnya 97
merepresentasikan huruf kecil ‘a’.
Penugasan sebenarnya memiliki sebuah
nilai. Nilai ini ditugaskan kepada variabel di sebelah kiri dari =. Nilai dari ekspresi penugasan nilai = getchar() adalah karakter yang dijadikan nilai balik oleh fungsi getchar dan ditugaskan kepada variabel nilai.
Fakta bahwa penugasan memiliki nilai
dapat berguna untuk menetapkan beberapa variabel sehingga memiliki nilai sama.
Sebagai contoh,
a = b = c = 0;
penugasan c = 0 pertama-tama dievaluasi (karena operator = berasosiasi dari kanan ke
kiri). Variabel b kemudian
ditugasi nilai dari penugasan c = 0 ( yang bernilai
0). Kemudian, variabel a ditugasi nilai
dari penugasan b = (c = 0) (yang juga
bernilai 0). Di dalam program, nilai dari penugasan nilai = getchar() dibandingkan dengan nilai dari EOF (sebuah simbol dengan
kepanjangan “end-of-file”). EOF digunakan
(yang normalnya memiliki nilai -1) sebagai nilai sentinel. EOF merupakan sebuah
konstanta integer simbolik yang didefinisikan di dalam header <stdio.h>. Jika nilai yang ditugasi kepada nilai sama dengan EOF, maka program akan berhenti.
Pada sistem Linux/Mac OS X, indikator
EOF dientrikan dengan mengetikkan
<Ctrl>
d
Notasi ini <Ctrl> d berarti menekan kunci ENTER dan kemudian secara bersamaan
menekan kunci Ctrl dan kunci d.
Pada sistem lain, seperti Microsoft
Windows, indikator EOF dapat dientrikan dengan mengetikkan
<Ctrl>
z
Pengguna memasukkan nilai-nilai pada
papanketik. Ketika kunci ENTER ditekan, karakter-karakter yang dientrikan
dibaca lewat fungsi getchar karakter demi
karakter. Jika karakter yang dientrikan tidak sama dengan EOF, maka statemen switch (baris 22) akan dieksekusi. Katakunci switch diikuti oleh nama variabel nilai yang diapit oleh kurung. Ini dikenal dengan ekspresi
kendali. Nilai dari ekspresi ini dibandingkan dengan setiap label case. Bila diasumsikan pengguna telah mengentrikan huruf C
sebagai sebuah nilai, maka C secara otomatis dibandingkan dengan setiap case di dalam switch. Jika ada
kecocokan (case ‘C’:), maka statemen untuk case tersebut akan dieksekusi. Pada
kasus huruf C, cHitung diinkremen
sebesar 1 (baris 36), dan statemen switch keluar melalui
statemen break.
Gambar 3.8 | Statemen seleksi-jamak switch dengan break
Statemen break menyebabkan kendali program berlanjut ke statemen pertama setelah
statemen switch. Statemen break digunakan karena semua case di dalam
statemen switch akan dieksekusi secara bersamaan. Jika
break tidak dipakai di dalam statemen switch, maka setiap kali terjadi kecocokan,
statemen pada semua case akan
dieksekusi. Jika tidak ada kecocokan, kasus default akan dieksekusi dan pesan error akan ditampilkan.
Setiap case memiliki satu atau lebih aksi. Statemen switch berbeda dari semua statemen kontrol yang lain dimana sepasang kurung
kurawal tidak diperlukan untuk mengapit aksi (atau beberapa aksi) di dalam
sebuah case dari statemen switch. Grafik-alir dari statemen
seleksi-jamak switch (menggunakan
sebuah break di dalam setiap case) ditampilkan pada Gambar 3.8. Grafik-alir tersebut membuat
jelas bahwa setiap statemen break di akhir suatu case menyebabkan kendali program keluar dari statemen switch.
Di dalam statemen switch pada Gambar
3.7, empat baris
case '\n': /*
mengabaikan garis-baru, */
case
'\t': /* tab, */
case
' ': /* dan spasi dalam masukan */
break; /* keluar switch */
menyebabkan program untuk mengabaikan
karakter garis-baru, tab, dan spasi. Pembacaan karakter demi karakter dapat
menyebabkan beberapa masalah. Agar program dapat membacanya, karakter-karakter
tersebut dikirim ke komputer dengan menekan kunci ENTER. Ini menyebabkan
karakter garis-baru ditempatkan di dalam masukan setelah karakter terakhir
dibaca. Seringkali, karakter garis-baru ini harus diproses secara khusus agar
program dapat bekerja dengan benar. Dengan menyertakan beberapa case di dalam statemen switch, Anda dapat mencegah pesan error di dalam kasus default untuk ditampilkan
setiap kali dijumpai karakter garis-baru, tab, atau spasi.
Ketika menggunakan statemen switch, ingat bahwa setiap case secara individual hanya dapat menguji ekspresi integral
konstanta, yaitu sembarang kombinasi konstanta karakter dan konstanta integer.
Sebuah konstanta karakter direpresentasikan sebagai karakter spesifik yang
diapit oleh kutip tunggal, seperti ‘A’.
Karakter tersebut harus diapit dengan kutip tunggal agar dikenali sebagai
konstanta karakter, sedang karakter yang diapit dengan kutip ganda dikenali
sebagai string. Konstanta integer merupakan nilai integer itu sendiri.
Catatan Untuk
Tipe Integral
Bahasa portabel seperti C memiliki
ukuran tipe data yang fleksibel. Berbagai aplikasi yang berbeda membutuhkan
ukuran integer yang berbeda pula. C menyediakan beberapa tipe data untuk
merepresentasikan integer. Rentang nilai untuk setiap tipe bergantung pada
perangkat keras komputer tertentu. Selain int dan char, C juga menyediakan tipe short (singkatan dari short int) dan long (singkatan dari long int). C
menspesifikasi rentang minimum nilai untuk integer short berada dalam -32768 sampai +32767. Untuk kebutuhan kalkulasi integer yang
besar, integer long dirasa cukup.
Rentang minimum untuk nilai integer long berada dalam
-2147483648 sampai +2147483647. Rentang minimum untuk nilai integer long berada dalam -2147483648 sampai +2147483647. Bahasa C
mensyaratkan bahwa rentang nilai untuk int sedikitnya sama dengan rentang nilai untuk short dan tidak lebih besar dari rentang integer long. Tipe data signed char dapat dipakai untuk merepresentasikan integer
dalam rentang -128 sampai +127 atau sembarang karakter di dalam himpunan
karakter komputer.
3.8 Statemen Repetisi do...while
Statemen repetisi do...while sama dengan statemen while. Di dalam statemen while, kondisi kontinuasi-loop diuji di awal loop sebelum tubuh loop
dieksekusi. Statemen do...while menguji kondisi
kontinuasi-loop setelah tubuh loop dieksekusi. Oleh karena itu, tubuh loop akan
dieksekusi sedikitnya sekali di dalam statemen do...while. Ketika statemen do...while berhenti,
eksekusi berlanjut ke statemen setelah klausa while. Tidak perlu menggunakan kurung kurawal di dalam statemen do...while jika terdapat hanya satu statemen di
dalam tubuh. Tetapi, kurung kurawal tersebut tetap dipakai untuk menghindari
kebingungan antara statemen while dan statemen do...while. Misalnya,
while ( kondisi )
umumnya dipandang sebagai header bagi
sebuah statemen while. Sebuah
statemen do...while tanpa kurung kurawal yang mengapit
tubuh statemen-tunggal dituliskan sebagai
do
statemen
while ( kondisi );
yang bisa membingungkan. Baris
terakhir, while(kondisi), bisa disalah-interpretasikan sebagai
suatu statemen while yang memuat
statemen kosong. Jadi, untuk menghindari kebingungan, do...while dengan satu statemen seringkali
dituliskan sebagai berikut:
do
{
statemen
} while ( kondisi );
Gambar 3.9 menggunakan sebuah statemen do...while untuk menampilkan angka dari 1 sampai
10. Variabel kontrol kounter dipreinkremen di dalam pengujian kontinuasi-loop.
Perhatikan pula kegunaan kurung kurawal untuk mengapit tubuh statemen-tunggal
dari do...while.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
/* Gambar 3.9: gambar03_09.c
Penggunaan statemen repetisi do/while */
#include <stdio.h>
/* fungsi main memulai eksekusi program */
int main( void )
{
int
kounter = 1; /* menginisialisasi kounter */
do {
printf( "%d ",
kounter ); /* menampilkan kounter */
} while ( ++kounter
<= 10 ); /* akhir dari do...while */
return 0; /* mengindikasikan program
berakhir dengan sukses */
} /* akhir dari fungsi main */
|
1 2 3 4 5 6 7 8 9 10
Gambar 3.9 | Contoh
statemen do...while
Gambar 3.10 menunjukkan grafik-alir
statemen do...while, yang menjelaskan bahwa kondisi
kontinuasi-loop tidak dieksekusi sampai setelah aksi dieksekusi sedikitnya
sekali.
Gambar 3.10 | Grafik-alir dari statemen repetisi do...while
3.9 Statemen break dan continue
Statemen break dan continue digunakan untuk mengubah aliran
kendali program. Statemen break, ketika
dieksekusi di dalam statemen while, do...while, atau switch, menyebabkan kendali program keluar dari statemen tersebut. Eksekusi
program berlanjut ke statemen berikutnya. Penggunaan yang umum atas statemen break adalah untuk segera keluar dari loop atau untuk melompati
sisa statemen di dalam suatu switch (seperti pada
Gambar 3.7). Gambar 3.11 mendemonstrasikan statemen break di dalam statemen repetisi for. Ketika
statemen if mendeteksi bahwa x telah menjadi 5, maka break dieksekusi. Ini menghentikan statemen for, dan program berlanjut untuk mengeksekusi printf yang terletak setelah for. Loop for hanya
dieksekusi sebanyak empat kali.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/* Gambar. 3.11: gambar03_11.c
Penggunaan statemen break di dalam statemen for */
#include <stdio.h>
/* fungsi main memulai eksekusi program */
int main( void )
{
int
x; /* kounter */
/*
loop 10 kali */
for
( x = 1; x <= 10; x++ ) {
/*
jik x adalah 5, loop berhenti */
if ( x == 5 ) {
break;/* keluar loop hanya jika x=5
*/
} /* akhir if */
printf( "%d ", x ); /*
menampilkan nilai x */
} /*
akhir for */
printf(
"\nKeluar dari loop pada x == %d\n", x );
return 0; /* mengindikasikan program
berakhir dengan sukses */
} /* akhir dari fungsi main */
|
1 2 3 4
Keluar dari loop pada x == 5
Gambar 3.11 | Penggunaan break di dalam statemen for
Statemen continue, ketika dieksekusi di dalam statemen while, do...while, dan for, akan melompati sisa statemen di dalam tubuh statemen kendali tersebut
dan selanjutnya program akan mengeksekusi iterasi loop berikutnya. Di dalam
statemen while dan do...while, pengujian kontinuasi-loop dievaluasi sesaat setelah statemen continue dieksekusi. Di dalam statemen for, ekspresi inkremen dieksekusi sesaat setelah statemen continue dieksekusi, kemudian pengujian
kontinuasi-loop dievaluasi.
Sebelumnya, telah dikatakan bahwa
statemen while dapat digunakan pada kebanyakan kasus
untuk merepresentasikan statemen for. Salah satu
pengecualian dari hal tersebut terjadi ketika ekspresi inkremen di dalam
statemen while dieksekusi setelah statemen continue. Pada kasus itu, inkremen tidak
dieksekusi sebelum kondisi kontinuasi-loop dievaluasi, dan oleh karena itu,
statemen while tidak dieksekusi dengan cara yang sama
dengan pengeksekusian statemen for. Gambar 3.12
menggunakan statemen continue di dalam suatu
statemen for untuk melompati statemen printf dan berlanjut ke iterasi berikutnya
dari loop.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
/* Gambar.3.12: gambar03_12.c
Penggunaan statemen continue di dalam statemen for */
#include <stdio.h>
/* fungsi main untuk memulai eksekusi */
int main( void )
{
int
x; /* kounter */
/* loop beriterasi 10 kali */
for ( x = 1; x <= 10; x++ ) {
/* jika x=5, lanjut ke iterasi berikutnya
pada loop */
if ( x == 5 ) {
continue; /* melompati sisa kode di dalam tubuh loop */
} /* akhir if */
printf( "%d ", x ); /*
menampilkan nilai x */
} /* akhir for */
printf( "\nMenggunakan continue untuk
melompati penampilan nilai 5\n" );
return 0; /* mengindikasikan program
berhenti dengan sukses */
} /* akhir dari fungsi main */
|
1 2 3 4 6 7 8 9 10
Menggunakan continue untuk melompati
penampilan nilai 5
Gambar 3.12 | Penggunaan continue di dalam statemen for
3.10 Operator Logikal
Sejauh ini, Anda hanya belajar beberapa
kondisi sederhana, seperti kounter <= 10, total > 1000, dan jumlah != nilaiSentinel. Anda telah
mengekspresikan semua kondisi tersebut menggunakan operator relasional, >,
<, >=, dan <=, dan operator ekualitas, == dan !=. Setiap keputusan
diuji menggunakan satu kondisi. Untuk menguji kondisi jamak di dalam proses
pembuatan suatu keputusan, Anda harus melakukannya secara terpisah atau di
dalam statemen if atau if...else bersarang.
C menyediakan operator logikal yang bisa
digunakan untuk membentuk kondisi yang lebih kompleks dengan menggabungkan
beberapa kondisi sederhana. Operator logikal yang ada adalah && (AND logikal), || (OR logikal), dan ! (NOT logikal). Akan disajikan beberapa contoh untuk setiap operator ini.
Dimisalkan bahwa Anda berharap untuk
memastikan bahwa kedua kondisi bernilai true sebelum memilih suatu jalur eksekusi tertentu. Pada kasus ini, Anda dapat
menggunakan operator logikal && sebagai
berikut:
if ( jenis_kelamin == 1 && usia >= 65 )
++wanitaUsiaLanjut;
Statemen if ini memuat dua kondisi sederhana. Kondisi jenis_kelamin == 1 dievaluasi untuk menentukan apakah seseorang wanita atau
tidak. Kondisi usia >= 65 dievaluasi
untuk menentukan apakah seseorang berusia lanjut atau tidak. Kedua kondisi
sederhana dievaluasi lebih dahulu karena keutamaan == dan >= keduanya lebih tinggi daripada
keutamaan &&.Statemen if kemudian kemudian memuat kondisi tergabung
jenis_kelamin == 1 && usia >= 65
Kondisi ini bernilai true jika dan hanya jika kedua kondisi sederhana tersebut
bernilai true. Jika kondisi tergabung ini bernilai true, maka jumlah wanitaUsiaLanjut diinkremen sebesar 1. Jika salah satu atau kedua kondisi sederhana itu
bernilai false, maka program akan melompati
penginkremenan dan berlanjut ke statemen setelah if.
Gambar 3.13 menyimpulkan operator &&. Tabel tersebut menunjukkan bahwa empat
kombinasi yang mungkin terjadi antara nol (false) dan tak-nol (true) untuk nilai ekspresi1 dan ekspresi2. Tabel seperti itu dinamakan tabel kebenaran. C mengevaluasi semua
ekspresi yang menyertakan operator relasional, operator ekualitas, dan operator
logikal menjadi bernilai 0 atau 1. Meskipun C menentapkan nilai true sebagai 1, namun C juga menerima sembarang nilai tak-nol
sebagai true.
ekspresi1
|
ekspresi2
|
ekspresi1 && ekspresi2
|
0
0
tak-nol
tak-nol
|
0
tak-nol
0
tak-nol
|
0
0
0
1
|
Gambar 3.13 | Tabel kebeneran untuk operator
logikal &&
Sekarang, Anda perhatikan operator || (OR logikal). Dimisalkan Anda berharap untuk memastikan di
suatu titik di dalam program bahwa salah satu atau kedua kondisi bernilai true sebelum Anda memilih jalur eksekusi tertentu. Pada kasus
ini, Anda dapat menggunakan operator || seperti di dalam potongan program
berikut:
if ( ujianMid >= 90 || ujianAkhir >= 90 )
printf( "Nilai mahasiswa adalah A\n" );
ekspresi1
|
ekspresi2
|
ekspresi1 || ekspresi2
|
0
0
tak-nol
tak-nol
|
0
tak-nol
0
tak-nol
|
0
1
1
1
|
Gambar 3.14 | Tabel kebeneran untuk operator
logikal ||
Statemen ini juga memuat dua kondisi
sederhana. Kondisi ujianMid >= 90 dievaluasi untuk menentukan apakah mahasiswa layak mendapatkan “A” di
dalam perkuliahan dipandang dari ujian tengah semesternya. Kondisi ujianAkhir >= 90 dievaluasi untuk menentukan apakah
mahasiswa layak mendapatkan “A” di dalam perkuliahan dipandang dari ujian
tengah akhirnya. Statemen if kemudian mempertimbangkan kondisi tergabung
ujianMid >= 90 || ujianAkhir >= 90
dan memberikan mahasiswa nilai “A” jika
salah satu atau kedua kondisi sederhana tersebut bernilai true. Pesan “Nilai mahasiswa adalah A” tidak ditampilkan hanya ketika kondisi
tersebut bernilai false (nol). Gambar
3.14 merupakan tabel kebenaran untuk operator OR logikal (||).
Operator && memiliki derajat
keutamaan lebih tinggi daripadai ||. Kedua operator tersebut berasosiasi dari
kiri ke kanan. Suatu ekspresi yang memuat operator && atau ||
dievaluasi hanya ketika kebenaran atau kesalahan diketahui. Jadi, evaluasi
terhadap kondisi
jenis_kelamin == 1 && usia >= 65
akan berhenti jika jenis_kelamin tidak sama dengan 1 (keseluruhan
ekspresi akan bernilai false), dan berlanjut
jika jenis_kelamin sama dengan 1 (keseluruhan ekspresi
dapat bernilai true jika usia >= 65 bernilai true). Fitur untuk evaluasi terhadap ekspresi AND logikal dan OR logikal ini
disebut pula dengan evaluasi jalan-pintas.
C juga menyediakan operator ! (negasi
logikal) untuk memampukan seorang programer dalam “membalik” arti sebuah kondisi.
Tidak seperti operator && dan ||, yang menggabungkan dua kondisi (dan
oleh karena itu merupakan operator biner), operator negasi logikal hanya
memiliki satu kondisi sebagai operannya (dan oleh karena itu merupakan operator
unary). Operator negasi logikal ditempatkan sebelum sebuah kondisi, seperti
dalam potongan program berikut:
if ( !( nilai == nilaiSentinel ) )
printf( "Nilai berikutnya adalah %f\n", nilai );
Sepasang kurung yang mengapit kondisi nilai == nilaiSentinel dibutuhkan karena operator negasi
logikal memiliki derajat keutamaan lebih tinggi daripada operator ekualitas.
Gambar 3.15 menunjukkan tabel kebenaran untuk operator negasi logikal.
ekspresi
|
!ekspresi
|
0
tak-nol
|
1
0
|
Gambar 3.15 | Tabel kebeneran untuk operator !
Pada kebanyakan kasus, Anda dapat
menghindari penggunaan operator negasi logikal dengan mengekspresikan kondisi
secara berbeda menggunakan operator relasional yang sesuai. Sebagai contoh,
statemen sebelumnya dapat ditulis-ulang sebagai berikut:
if ( nilai != nilaiSentinel )
printf( "Nilai berikutnya adalah %f\n", nilai );
Gambar 3.16 menunjukkan keutamaan dan
asosiatifitas semua operator yang telah dikenalkan sejauh ini. Semua operator
tersebut ditampilkan dari atas ke bawah dengan urutan derajat keutamaan
menurun.
Operator
|
Asosiatifitas
|
Tipe
|
++ (postfiks) -- (postfiks)
+ -
! ++ (prefiks) -- (prefiks)
* / %
+ -
< <=
> >=
== !=
&&
||
?:
= +=
-= *= /=
%=
,
|
kanan ke kiri
kanan ke kiri
kiri ke kanan
kiri ke kanan
kiri ke kanan
kiri ke kanan
kiri ke kanan
kiri ke kanan
kanan ke kiri
kanan ke kiri
kiri ke kanan
|
postfiks
unary
multiplikatif
aditif
relasional
ekualitas
AND logikal
OR logikal
kondisional
penugasan
koma
|
Gambar 3.15 | Keutamaan dan asosiatifitas operator
3.11 Operator Ekualitas (==) dan
Penugasan (=) yang Membingungkan
Ada satu jenis error yang dilakukan
para programer C, bagaimanapun berpengalamannya mereka, cenderung untuk membuat
kesalahan berulang. Error tersebut adalah penukaran operator == (ekualitas) dan
= (penugasan). Apa yang membuat penukaran operator ini begitu berbahaya adalah
fakta bahwa kesalahan ini tidak menyebabkan error kompilasi. Tetapi, statemen
dengan kesalahan seperti ini dapat dikompilasi secara utuh, menyebabkan program
berjalan tanpa masalah, dan menghasilkan keluaran yang tidak tepat karena kesalahan
logika yang dikandungnya.
Dua aspek C yang menyebabkan masalah
ini. Pertama adalah bahwa sembarang ekspresi dalam C yang menghasilkan suatu
nilai dapat digunakan dalam bagian keputusan dari sembarang statemen kendali.
Jika nilai bernilai 0, maka diperlakukan sebagai false, dan jika nilai tak-nol, maka diperlakukan sebagai true. Kedua adalah bahwa penugasan dalam C menghasilkan suatu
nilai, yaitu nilai yang ditugaskan kepada variabel yang berada di sebelah kiri
operator penugasan. Sebagai contoh, dituliskan
if ( kodePembayaran == 4 )
printf( "Anda mendapatkan bonus!" );
tetapi Anda secara tidak sengaja
menuliskan
if ( kodePembayaran = 4 )
printf( "Anda mendapatkan bonus!" );
Statemen if yang pertama secara benar menghadiahkan bonus kepada seseorang yang
memiliki kode pembayaran sama dengan 4. Statemen if yang kedua, yang memiliki kesalahan, mengevaluasi ekspresi penugasan di
dalam kondisi if. Ekspresi ini
merupakan suatu penugasan sederhana yang memiliki nilai 4. Karena sembarang
nilai tak-nol diinterpretasikan sebagai true, kondisi di dalam statemen if ini selalu true, akibatnya tidak hanya nilai kodePembayaran secara tidak sengaja ditetapkan menjadi 4, tatapi juga
seseorang akan selalu mendapat bonus tanpa memandang berapa nilai kodePembayaran yang dimilikinya.
Ada hal menarik lainnya yang penting
Anda ketahui. Dimisalkan Anda ingin menugaskan sebuah nilai kepada suatu
variabel dengan statemen sederhana seperti
x = 1;
tetapi secara tidak sengaja Anda
menuliskan
x == 1;
Di sini, juga, terjadi error sintaks.
Kompiler hanya mengevaluasi ekspresi kondisional. Jika x bernilai 1, maka kondisi bernilai true dan ekspresi tersebut menghasilkan nilai 1. Jika x tidak sama dengan 1, maka kondisi bernilai false dan ekspresi menghasilkan nilai 0. Apapun nilai dari
ekspresi tersebut, karena tidak ada operator penugasan, nilai x tetap tidak berubah.
3.12 Simpulan Pemrograman Terstruktur
Gambar 3.17 menyimpulkan beberapa
statemen kendali yang telah dipelajari pada Bab 2 dan Bab 3. Lingkaran kecil
dipakai di dalam gambar untuk mengindikasikan titik masuk tunggal dan titik
keluar tunggal dari setiap statemen. Penghubungan simbol-simbol grafik-alir
secara acak dapat mengarah ke pemrograman tak-terstruktur. Oleh karena itu,
para programer secara hati-hati menggabungkan beberapa simbol grafik-alir untuk
membentuk himpunan terbatas dari statemen kendali, dan untuk membangun program
terstruktur dengan secara tepat menggabungkan beberapa statemen kendali dalam
dua cara. Agar lebih sederhana, hanya statemen kendali
masukan-tunggal/keluaran-tunggal yang digunakan, yaitu hanya ada satu cara
untuk memasuki dan hanya ada satu cara untuk keluar dari setiap statemen
kendali.
Gambar 3.18 menunjukkan beberapa aturan
dalam membentuk program terstruktur. Aturan tersebut mengasumsikan bahwa simbol
grafik-alir persegi-panjang dapat dipakai untuk mengindikasikan sembarang aksi
termasuk masukan/keluaran. Gambar 3.19 menunjukkan grafik-alir paling
sederhana.
Penerapan aturan pada Gambar 3.18
selalu menghasilkan suatu grafik-alir terstruktur dengan blok pembangun yang
rapi. Penerapan Aturan 2 secara berulang terhadap grafik-alir tersederhana
(Gambar 3.19) menghasilkan suatu grafik-alir terstruktur yang memuat banyak
simbol persegi-panjang dalam runtun (Gambar 3.20). Perhatikan bahwa Aturan 2
menghasilkan setumpuk statemen kendali; jadi, Aturan 2 dikenal pula dengan
aturan penumpukan.
Aturan 3 disebut dengan aturan
penyarangan. Penerapan Aturan 3 secara berulang terhadap grafik-alir
tersederhana menghasilkan suatu grafik-alir dengan beberapa statemen kendali
bersarang. Sebagai contoh, pada Gambar 3.21, simbol persegi-panjang di dalam
grafik-alir tersederhana terlebih dahulu diganti dengan suatu statemen
seleksi-ganda (if...else). Kemudian
Aturan 3 diterapkan kembali terhadap kedua simbol persegi-panjang di dalam
statemen seleksi-ganda, mengganti setiap simbol persegi-panjang tersebut dengan
statemen seleksi-ganda.
Gambar 3.17 | Runtun
masukan-tunggal/keluaran-tunggal, statemen seleksi, dan statemen repetisi
Aturan 4 menghasilkan struktur
bersarang yang lebih besar. Grafik-alir yang dihasilkan dari penerapan beberapa
aturan pada Gambar 3.18 merupakan himpunan semua grafik-alir terstruktur yang
mungkin dihasilkan.
Aturan untuk membentuk program terstruktur
|
1) Mulai dengan “grafik-alir”
yang paling sederhana (Gambar 3.19).
2) Sembarang simbol
persegi-panjang (aksi) dapat digantikan dengan dua simbol persegi-panjang
(aksi) dalm runtun.
3) Sembarang simbol
persegi-panjang (aksi) dapat digantikan dengan sembarang statemen kendali
(runtun, if, if...else, switch, while, do...while, atau, for.
4) Aturan 2 dan 3 dapat
diterapkan secara berulang.
|
Gambar 3.18 | Beberapa aturan untuk membentuk
program terstruktur
Gambar 3.19 | Grafik-alir paling sederhana
Gambar 3.20 | Penerapan Aturan 2 secara berulang
terhadap grafik-alir tersederhana
Gambar 3.21 | Penerapan Aturan 3 secara berulang
terhadap grafik-alir tersederhana
Gambar 3.22 | Blok pembangun tertumpuk, bersarang,
dan tertindih
Gambar 3.22 menunjukkan beberapa jenis
blok pembangun tertumpuk yang dihasilkan dari penerapan Aturan 2 dan beberapa
jenis blok pembangun bersarang yang dihasilkan dari penerapan Aturan 3. Gambar
tersebut juga menampilkan beberapa jenis blok pembangun tertindih.
Soal
1.
Temukan kesalahan di dalam setiap potongan kode
berikut dan jelaskan bagaimana memperbaikinya.
a) x = 1;
while ( x <= 10 );
x++;
}
b) for ( y = .1; y != 1.0; y += .1 )
printf( "%f\n", y );
c) switch ( n ) {
case 1:
printf( "Angka adalah 1\n" );
case 2:
printf( "Angka adalah 2\n" );
break;
default:
printf( "Angka bukan 1 atau 2\n" );
break;
2.
Temukan kesalahan di dalam setiap potongan program
berikut. (Perhatikan: Bisa saja terdapat lebih dari satu kesalahan).
a)
for ( x = 100, x >= 1, x++ )
printf( "%d\n", x );
b)
Kode berikut harus menampilkan apakah integer yang diberikan ganjil atau
genap:
switch ( nilai % 2 ) {
case 0:
printf( "Integer genap\n" );
case 1:
printf( "Integer ganjil\n" );
}
c) Kode berikut
harus mengentrikan sebuah integer dan sebuah karakter dan menampilkan keduanya.
Diasumsikan bahwa pengguna mengetikkan 100 A sebagai masukan.
scanf( "%d", &intNilai );
charNilai = getchar();
printf( "Integer: %d\nKarakter: %c\n", intNilai, charNilai );
d) for ( x = .000001; x == .0001; x += .000001 ) {
printf( "%.7f\n", x );
}
e) Kode berikut harus menampilkan
integer-integer ganjil dari 999 sampai 1:
for ( x = 999; x >= 1; x += 2 ) {
printf(
"%d\n", x );
}
f)
Kode berikut harus menampilkan integer-integer
genap dari 2 sampai 100:
kounter = 2;
do {
if (kounter % 2 == 0 ) {
printf(
"%d\n", kounter);
}
kounter
+= 2;
} while (kounter < 100 );
g) Kode berikut
harus menampilkan penjumlahan integer dari 100 sampai 150 (diasumsikan bahwa total diinisialisasi
dengan 0):
for ( x = 100; x <= 150; x++ );
{
total
+= x;
}
3.
Sebutkan nilai-nilai variabel kontrol x yang ditampilkan oleh setiap statemen for sebagai berikut:
a)
for ( x = 2; x <= 13; x += 2 ) {
printf( "%d\n", x );
}
b)
for ( x = 5; x <= 22; x += 7 ) {
printf( "%d\n", x );
}
c)
for ( x = 3; x <= 15; x += 3 ) {
printf( "%d\n", x );
}
d)
for ( x = 1; x <= 5; x += 7 ) {
printf( "%d\n", x );
}
e)
for ( x = 12; x >= 2; x -= 3 ) {
printf(
"%d\n", x );
}
4.
Tulislah statemen for yang menampilkan runtun nilai sebagai berikut:
a)
1, 2, 3, 4, 5, 6, 7
b)
3, 8, 13, 18, 23
c)
20, 14, 8, 2, –4, –10
d)
19, 27, 35, 43, 51
5.
Apakah yang dilakukan program ini?
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
|
#include <stdio.h>
/* fungsi main memulai ekskusi program */
int main( void )
{
int x;
int y;
int i;
int j;
/* meminta pengguna memasukkan masukan */
printf( "Masukkan dua integer dalam rentang
1-20: " );
scanf( "%d%d",
&x, &y ); /* membaca nilai x dan y */
for ( i = 1; i <= y; i++ ) { /* menghitung dari 1
sampai y */
for ( j = 1; j <= x; j++ ) { /* menghitung dari 1
sampai x */
printf( "@" );
/* menampilkan @ */
} /* akhir dari for sebelah dalam */
printf( "\n" );
/* mulai garis baru */
} /* akhir dari for sebelah luar */
return 0; /* indikasi program berakhir dengan
sukses */
}
/* akhir dari fungsi main */
|
6.
Tulislah suatu program yang menjumlahkan sebuah runtun integer.
Asumsikan bahwa integer pertama yang dibaca dengan scanf menspesifikasi jumlah nilai yang akan dimasukkan. Program Anda harus
membaca hanya satu nilai setiap kali scanf dieksekusi. Masukan yang dientrikan adalah 5 100
200 300 400
500, dimana 5 mengindikasikan jumlah nilai yang akan dimasukkan.
7.
Tulislah suatu program yang menghitung dan menampilkan rerata dari
beberapa integer. Asumsikan bahwa integer terakhir yang dibaca dengan scanf adalah nilai sentinel 9999.
Masukan yang diberikan adalah 10 8 11 7
9 9999, yang mengindikasikan perhitungan
rerata atas nilai-nilai sebelum angka 9999.
8.
Tulislah suatu program yang mencari nilai terkecil dari beberapa
integer. Asumsikan bahwa nilai pertama yang dibaca menspesifikasikan jumlah
nilai yang akan dimasukkan.
9.
Tulislah sebuah program yang menghitung dan menampilkan jumlah dari
integer-integer genap dari 2 sampai 30.
10.
Tulislah sebuah program yang menghitung dan menampilkan perkalian dari integer-integer
ganjil dari 1 sampai 17.
11.
Tulislah sebuah program yang menampilkan beberapa pola berikut ini.
Gunakan loop for untuk menghasilkan pola
tersebut.
12.
Asumsikan bahwa i = 1, j = 2, k = 3, dan m = 2. Apakah yang ditampilkan setiap
statemen berikut?
a)
printf( "%d", i == 1 );
b)
printf( "%d", j == 3 );
c)
printf( "%d", i >= 1 && j < 4 );
d)
printf( "%d", m < = 99 && k < m );
e)
printf( "%d", j >= i || k == m );
f)
printf( "%d", k + m < j || 3 - j >= k );
g)
printf( "%d", !m );
h)
printf( "%d", !( j - m ) );
i)
printf( "%d", !( k > m ) );
j)
printf( "%d", !( j > k ) );
No comments:
Post a Comment