Pemrograman Modular

Secara Imperatif Prosedural

dengan Bahasa Pascal Versi 0.3 alpha

Oleh : Mario Ray M.

1

Kata Pengantar

Buku ini (diharapkan) dapat digunakan sebagai panduan dalam pengajaran

pemrograman dasar yang bersifat prosedural. Di sisi lain, karena ditulis dengan

posisi penulis sebagai pengajar, buku ini dapat juga digunakan sebagai tutorial

untuk para self-learner.

Buku ini mencoba berbeda dari buku lain yang sejenis, yaitu dengan

menggunakan pendekatan pengajaran learning by analyzing. Saat buku lain

memulai secara teoritis, baru kemudian dilanjutkan dengan kode, buku ini justru

menggunakan kode sebagai basis pengajaran. Kode tersebut yang kemudian akan

ditelaah dan dipelajari untuk menggali konsep-konsep yang ada dalam

pemrograman prosedural.

Bahasa pemrograman yang digunakan adalah bahasa Pascal. Karena selain

ketenarannya dalam dunia pendidikan, juga karena sifatnya yang struktural

memaksa programmer untuk menulis kode yang tersusun rapi, type-safety yang

menjamin keamanan kode saat kompilasi, dan runtime-checking yang sangat

membantu proses pemeriksaan saat menjalankan program. Didukung dengan

pesan error yang cukup jelas, mempermudah pencarian kesalahan dalam kode

yang sering dialami programmer-programmer pemula.

2

Daftar Isi

Daftar Isi ............................................................................................................ 2 Sejarah Singkat Bahasa Pascal ......................................................................... 4 Prasyarat & Perlengkapan yang Diperlukan ................................................... 6 Struktur Program Pascal................................................................................... 7 Halo, Dunia! ..................................................................................................... 10 Perhitungan Matematika................................................................................. 15 Masukan dan Keluaran ................................................................................... 19

Masukan sederhana (tanpa kemungkinan error) ....................................... 19 Masukan dengan kemungkinan error......................................................... 21

Pemberian Nilai ............................................................................................... 23 Pemberian nilai pada saat eksekusi............................................................. 23 Pemberian nilai pada saat deklarasi (inisialisasi) ....................................... 24

Perintah Bercabang ......................................................................................... 26 if ... then ... else ............................................................................................. 26 case ... of........................................................................................................ 30

Bilangan Acak .................................................................................................. 33 Pengulangan 1: Iterasi ..................................................................................... 35

for .. to / downto .. do ................................................................................... 36 while .. do...................................................................................................... 37 repeat .. until ................................................................................................ 38

Ujian 1 .............................................................................................................. 41 Subprogram ..................................................................................................... 42

Prosedur ....................................................................................................... 42 Argumen / Parameter .................................................................................. 43 Prosedur di Dalam Prosedur ....................................................................... 44 Aturan Ruang Lingkup ............................................................................... 45 Penyampaian Parameter ............................................................................. 47 Fungsi ........................................................................................................... 49 Referensi Maju............................................................................................. 50

Pengulangan 2 : Rekursi .................................................................................. 53 Tipe Data Lanjutan.......................................................................................... 55

Larik / Array ................................................................................................ 55 Enumeration / Pencacahan .......................................................................... 59

3

Himpunan / Set............................................................................................. 59 Rekaman / Record........................................................................................ 59 Penunjuk / Pointer ....................................................................................... 59 Berkas / File.................................................................................................. 59 Tipe Data Prosedural ................................................................................... 59

4

Sejarah Singkat Bahasa Pascal

Pascal dirancang oleh seorang Professor di Polytechnic of Zurich, Swiss

bernama Niklaus Wirth. Beliau merupakan salah seorang anggota komite yang

yang pada tahun 1960-an mengembangkan bahasa Algol, yang merupakan akar

bahasa Pascal. Beliau membuat bahasa Pascal karena ketidakpuasannya dengan

bahasa-bahasa yang ada waktu itu, di mana kode-kode program tidak tersusun

dengan baik dan sulit dipertahankan1. Beliau ingin membuat sebuah bahasa

pemrograman yang terstruktur namun tetap sederhana dan mudah dipelajari. Dari

keinginannya tersebut, lahirlah bahasa Pascal. Pascal diumumkan ke publik pada

tahun 1969, dengan implementasi compiler2 pertama setahun sesudahnya.

Dalam perjalanannya, Pascal terpecah menjadi dua kelompok dialek.

Tepatnya sekitar tahun 80an saat sebuah operating system dan compiler UCSD

Pascal dirilis. UCSD Pascal memperkenalkan sistem unit untuk modularisasi dan

tipe string. Selain itu, ia juga memperkenalkan p-code yang merupakan cikal

bakal dari bytecode Java.

Kelompok pertama adalah Pascal orisinil dan pada tahun 1990 dibuat ISO-

nya (7185), diikuti dengan Extended Pascal (10206) pada tahun yang sama.

Sayangnya, pengguna kelompok ini tidak terlalu banyak sehingga compiler yang

mengimplementasikan dialek ini pun hanya sedikit. Saat ini, hanya terdapat

sekitar 5 kompilator yang masih bertahan, yaitu Prospero Extended Pascal, IP

Pascal, Dr. Pascal, dan GNU Pascal (GPC). Semuanya ditulis dalam bahasa

Pascal, kecuali GPC yang ditargetkan sebagai front-end dari GCC sehingga ditulis

dalam bahasa C.

Kelompok kedua merupakan Pascal yang banyak digunakan saat ini, yaitu

turunan dari UCSD Pascal. Turbo Pascal adalah salah satu compiler keluaran

Borland tersukses yang termasuk turunan UCSD Pascal. Ia meng-extend UCSD

Pascal dengan object, memungkinkan permrograman berorientasi objek (PBO /

OOP) dengan Pascal, menambah beberapa tipe data seperti PChar, dan 1 sering juga disebut spaghetty code 2 program yang mengubah kode sumber menjadi program yang bisa dieksekusi

5

melonggarkan beberapa aturan Pascal orisinil sehingga membuat Pascal cocok

untuk pemrograman sistem. Turbo Pascal ditulis dalam bahasa assembler,

sehingga tidak mengherankan jika kecepatannya luar biasa. Setelah masa

keemasan Turbo Pascal berakhir, dirilis Delphi yang kemudian menjadi standar

Object Pascal / Modern Pascal. Delphi mengubah konsep OOP Turbo Pascal

sehingga menjadi lebih natural dengan mengubah object menjadi class, tentunya

dengan ekstensi lain yang membuat bahasa ini semakin kuat. Di saat yang sama,

Free Pascal (FPC) juga mulai dikembangkan dan menargetkan kompatibilitas

dengan Turbo Pascal maupun Delphi. Perbedaannya, Delphi dibuat khusus untuk

Windows, sementara FPC dibuat cross-platform. Selain itu, compiler Delphi

ditulis dalam bahasa C++ sementara FPC ditulis dalam bahasa Pascal.

Pascal banyak digunakan dalam dunia pendidikan, terutama untuk

mengajarkan pemrograman. Namun, sekarang ini mulai banyak digunakan dalam

dunia industri karena kompilatornya sekarang sudah ada yang 32-bit atau bahkan

64-bit dan multiplatform, menggantikan C/C++ karena kemudahan membuat

program yang maintainable dan mengurangi proses debugging3 namun dengan

kecepatan yang relatif sama bahkan dengan penggunaan memori yang lebih

efisien.

3 pemeriksaan akan adanya kesalahan pada program

6

Prasyarat & Perlengkapan yang Diperlukan

Diperlukan kemampuan bahasa Inggris yang cukup karena banyak istilah

bahasa Inggris yang akan digunakan. Selain itu, diperlukan kemampuan dasar

mengenai console / command prompt4 (Misalnya, berpindah directory).

1. Compiler

Sebagian besar kompilator Pascal modern (misal: Free Pascal) bisa

digunakan. Harap baca dokumentasi kompilator yang Anda gunakan. Paling

tidak, carilah informasi bagaimana cara mengompilasi sebuah program.

2. Editor / IDE

Editor apapun mulai dari yang paling sederhana (misal: Notepad) sampai

yang berbentuk RAD (misal: Lazarus) bisa digunakan. Jangan gunakan word

processor5 (misal: Microsoft Word) karena biasanya word processor

memiliki kemampuan untuk memperbaiki tulisan yang seringkali

mempersulit pengetikan kode, selain itu word processor juga memiliki format

khusus, walaupun sebagian besar bisa juga menyimpan dengan format teks

biasa. Disarankan untuk menggunakan editor yang memiliki nomor baris,

dengan kemampuan syntax highlighting6, code completion7, dan code

templates8 (misal: SciTE) karena itu akan sangat mengurangi beban

pengetikan.

4 Command prompt (Windows), Console, dan Terminal (Linux & MacOS) merujuk pada aplikasi yang sama, yaitu program di mana perintah diberikan dengan mengetik tulisan dengan keyboard ketimbang meng-klik icon dengan mouse 5 Word processor dibuat untuk membantu proses pembuatan dokumen sehingga diperlukan fitur-fitur yang bisa mempermudah proses tersebut, seperti memperbaiki tulisan yang salah ketik. Hal ini menyulitkan dalam penulisan kode program, misalnya untuk kata teh. Sebagian besar word processor mengenalinya sebagai ketikan yang salah dari kata the dan otomatis setiap kali kita mengetik teh akan langsung diganti dengan the 6 Pemberian corak khusus pada elemen tertentu dari suatu bahasa pemrograman 7 Penulisan kode secara otomatis untuk melengkapi suatu struktur 8 Penggunaan singkatan untuk menghasilkan suatu struktur

7

Struktur Program Pascal

Pascal merupakan bahasa imperative9 dan procedural10, artinya program

dalam bahasa Pascal terdiri atas kumpulan instruksi yang dieksekusi secara

berurutan. Bahasa lain yang termasuk dalam kelompok ini misalnya C & Fortran.

Secara umum, struktur program Pascal dapat dilihat pada bagan 1.1. Bagian-

bagian program tersebut (beserta struktur-struktur lain yang tidak tercakup) akan

kita pelajari pada bab-bab berikutnya.

Pascal adalah bahasa yang bersifat case-insensitive, artinya Pascal TIDAK

membedakan penulisan huruf besar maupun kecil. Begin, begin, BEGIN, bEgIn,

maupun BeGiN memiliki arti yang sama. Namun, demi kemudahan membaca,

disarankan untuk menggunakan 3 cara pertama dan sebaiknya konsisten sepanjang

program. Menurut panduan penulisan kode yang dikeluarkan Borland (produsen

Turbo Pascal dan Delphi), gunakan huruf kecil untuk kata kunci. Untuk nama

fungsi, tipe data, variabel, konstanta, dan elemen lainnya gunakan huruf kapital

(huruf pertama besar) untuk setiap kata. Contoh:

Kata kunci : program, begin, end, procedure, function, var, const, dst.

Lainnya : ProgramKu, FungsiXXX, Nama, Alamat, MintaInput, dst.

9 Bahasa pemrograman yang alur programnya berupa rangkaian instruksi 10 Bahasa pemrograman yang alur programnya berupa pemanggilan prosedur

8

{ Nama program, secara teknis tidak dibutuhkan } program judul_program; (* Penggunaan unit (pustaka) *) uses unit1,unit2,...,unitN; type // Definisi tipe global tipe1 = definisi_type1; tipe2 = definisi_type2; ... tipeN = definisi_typeN; const // Definisi konstanta global konstanta1 [: tipe_konstanta1] = nilai_konstanta1; konstanta2 [: tipe_konstanta2] = nilai_konstanta2; ... konstantaN [: tipe_konstantaN] = nilai_konstantaN; var // Deklarasi variabel global var1: tipe_variabel1 [= nilai_awal]; var2: tipe_variabel2 [= nilai_awal]; ... varN: tipe_variabelN [= nilai_awal]; procedure nama_prosedur[(arg1: tipe_argumen1; arg2: tipe_argumen2; ...; argN: tipe_argumenN)]; { Deklarasi variabel lokal (bisa juga tipe atau konstanta) } var var1: tipe_variabel1 [= nilai_awal]; var2: tipe_variabel2 [= nilai_awal]; ... varN: tipe_variabelN [= nilai_awal]; begin // Isi prosedur end; function nama_fungsi[(arg1: tipe_argumen1; arg2: tipe_argumen2; ...; argN: tipe_argumenN)]: tipe_nilai_balikan; { Deklarasi variabel lokal (bisa juga tipe atau konstanta) } var var1: tipe_variabel1 [= nilai_awal]; var2: tipe_variabel2 [= nilai_awal]; ... varN: tipe_variabelN [= nilai_awal]; begin // Isi fungsi end; begin // Isi program utama end.

Bagan 1.1 Struktur Program Pascal

9

Keterangan:

Cetak tebal Kata kunci

Warna biru Komentar

Warna merah Simbol

Kurung siku Pilihan (tidak wajib)

10

Halo, Dunia!

Program paling dasar dalam hampir semua pelajaran bahasa pemrograman

adalah Hello, World11. Program ini bekerja dengan sangat sederhana, hanya

mencetak sebuah kalimat ke dalam console / command prompt. Buka editor yang

Anda miliki, lalu ketikkan program berikut.

1 program Halo; 2 3 begin 4 WriteLn('Halo, Dunia!'); 5 end. 6

Program 1.1 Halo, Dunia!

Catatan

Kolom sebelah kiri adalah nomor baris, yang akan sangat berguna ketika kita akan

memusatkan kode pada bagian tertentu.

Simpan program tersebut dengan nama Halo.pas12, kemudian buka

command prompt dan ketikkan perintah untuk mengompilasi program tersebut.

Misalnya, untuk Free Pascal ketikkan (> adalah tanda prompt): > fpc Halo.pas Kemudian, jalankan program yang telah dikompilasi dengan mengetik: > Halo.exe untuk Windows, dan > ./Halo

11 Bentuk suatu bahasa biasanya bisa dilihat dari program paling sederhana yang bisa dibuatnya, di mana Hello, World! adalah yang paling umum digunakan 12 Ekstensi .pas hanyalah konvensi, namun demikian sangat disarankan untuk menggunakannya untuk membedakan dengan file-file lain. .pas hanya salah satu ekstensi program Pascal, contoh yang lain adalah .p. Beberapa kompilator juga menambahkan ekstensi sendiri untuk keperluan masing-masing

11

untuk Linux / MacOS. Jika program berhasil dikompilasi, maka akan muncul

tulisan: > Halo, Dunia! Sebaliknya, bila tidak, berarti Anda mendapat compile error13. Periksa kembali

program Anda, apakah mungkin ada titik koma yang terlewatkan, penulisan kata

kunci yang bersentuhan (tidak ada spasi yang memisahkan) dengan pengenal, dsb.

Catatan

Titik koma pada kalimat terakhir sebelum end TIDAK wajib, namun bila ada pun

tidak apa-apa. Disarankan untuk tetap menulisnya karena jika seandainya program

dimodifikasi dan ada kalimat baru yang dimasukkan setelahnya (artinya, kalimat

tersebut tidak lagi menjadi kalimat terakhir), Anda tidak akan mendapat error

karena lupa memberi titik koma.

Sekarang, kita pelajari program tersebut secara lebih mendalam. Pada baris

pertama, terdapat kata kunci program dan pengenal Halo, diakhiri dengan ;

(titik koma). Titik koma bagi Pascal merupakan pemisah antar kalimat dalam

program. Bagi beberapa kompilator (misal Free Pascal, Turbo Pascal, Delphi),

bagian ini TIDAK harus ada. Namun, demi mempertahankan kecocokan dengan

kompilator lain dan kejelasan program, disarankan agar tetap ditulis. Pada

dasarnya, bagian ini hanya memberikan nama dan tidak mempengaruhi jalannya

program.

Kata kunci (keywords / reserved words) merupakan bagian dari bahasa

Pascal dan tidak boleh digunakan sebagai pengenal (identifier). Tabel 1.1

menunjukkan kata kunci yang tersedia dalam bahasa Pascal (termasuk Object

Pascal). Pengenal adalah nama yang kita berikan pada bagian program tertentu

agar bisa dirujuk kemudian. Pengenal dalam Pascal dapat terdiri dari huruf, angka,

dan garis bawah dan HARUS diawali dengan huruf atau garis bawah. Panjang

13 Error yang terjadi saat proses kompilasi. Biasanya karena kesalahan syntax, tipe data yang tidak cocok, dsb. Error ini sangat berguna untuk mencegah program memberikan hasil yang tidak diinginkan, meskipun seringkali kesalahan terjadi karena kita tidak dapat merepresentasikan apa yang kita inginkan dalam bahasa yang dimengerti kompilator.

12

pengenal bisa berapapun, namun sebagian besar kompilator Pascal hanya akan

melihat 32 karakter pertama. Karena itu, gunakan nama dengan panjang yang

masuk akal (tidak lebih dari 15 karakter). Dengan begini, Anda juga mengurangi

waktu pengetikan.

Bagian program berikutnya, yaitu baris kedua dikosongkan. Tentu hal ini

tidak wajib, hanya saja ketika nanti program yang kita buat sudah mulai

kompleks, adanya baris kosong akan mempermudah kita memilah-milah bagian

absolute and array asm begin break case const constructor continue destructor div do downto else end file for function goto

if implementation in inherited inline interface label mod nil not object of on operator or otherwise packed procedure program record

reintroduce repeat self set shl shr string then to type unit until uses var while with xor as class except

exports finalization finally initialization is library on out property raise threadvar try dispose exit false new true generic specialization

Tabel 1.1 Kata kunci dalam bahasa Pascal

Catatan

Beberapa kata kunci hanya ada pada kompilator tertentu, misalnya generic dan specialization hanya ada pada Free Pascal pada mode ObjFPC atau Delphi. Namun, demi menjaga kecocokan antar kompilator, akan lebih baik jika Anda

menghindari semua kata-kata di atas.

program.

13

Pada baris ketiga terdapat kata kunci begin, yang diikuti dengan

pemanggilan prosedur14 WriteLn dengan argumen15 bertipe string berisi kalimat Halo, Dunia!.

String merupakan tipe data berupa untaian karakter yang diawali dan diakhiri dengan (tanda kutip). Untuk mencetak tanda kutip, tulis dua tanda kutip

secara berurutan. Semua karakter dalam string akan memiliki makna normalnya (tidak terkecuali kata kunci, operator, dan simbol-simbol lainnya).

WriteLn adalah prosedur internal yang dapat menerima argumen dalam

jumlah dan tipe yang bervariasi. Prosedur ini akan mencetak argumen-

argumennya dan diakhiri dengan baris baru (dalam keyboard, sama dengan Enter).

Sebelum mencetak, jika argumennya berupa ekspresi16, maka akan dievaluasi

terlebih dahulu, kemudian hasilnya diubah ke string. Karena itu, jika argumennya tidak dapat diubah ke string, kompilator akan memberikan compile error.

Sedangkan pada baris kelima terdapat kata kunci end yang diakhiri dengan

. (titik). Dalam suatu program, kumpulan instruksi yang berada dalam satu

kelompok disebut blok, yang dalam bahasa Pascal diawali dengan begin dan

diakhiri dengan end. Terdapat perbedaan antara end yang diakhiri dengan ; (titik

koma) dan . (titik). Untuk program, end harus diakhiri dengan titik. Sementara

elemen program yang lain menggunakan ;. Hal inilah yang mendasari beberapa

kompilator untuk mengabaikan bagian program seperti yang telah dijelaskan di

atas.

Baris terakhir yang dikosongkan diperlukan bagi beberapa kompilator

(misal GNU Pascal) sebagai penanda akhir file.

14 Seringkali (pastinya) dalam sebuah program, kita perlu melakukan rangkaian langkah yang sama namun hanya berbeda di beberapa tempat. Untuk itulah diciptakan prosedur (dan fungsi), sehingga hanya bagian yang berbeda itu yang perlu kita tulis 15 Seperti dalam matematika, fungsi dapat menerima argumen. Misalnya f(x) adalah fungsi bernama f dengan argumen x, g(a,b) adalah fungsi bernama g dengan argumen pertama a dan argumen kedua b, dst. 16 Operasi yang memberikan nilai

14

Kuis:

1. Apa perbedaan keywords dengan identifier?

2. Apa saja (minimal 3) penyebab terjadinya compile error?

15

Perhitungan Matematika

Pada dasarnya, semua program komputer adalah kalkulator, tinggal

bagaimana kita merepresentasikan perhitungan yang kita inginkan dalam bahasa

yang bisa dimengerti komputer. Hal ini sangat sulit dilakukan secara langsung,

karena meskipun terlihat sangat pintar, komputer sebenarnya hanya mengerti

penjumlahan dan perkalian, dan beberapa operasi lain yang tidak berhubungan

secara langsung dengan perhitungan matematis. Dengan bahasa pemrograman dan

bantuan kompilatornya, kita dapat melakukannya semudah menuliskannya pada

kertas. Program 2.1 menunjukkan contoh program yang melakukan perhitungan

1+2*3-4.

1 program Hitung; 2 3 begin 4 WriteLn('1+2*3-4 = ',1+2*3-4); 5 end. 6

Program 2.1 Perhitungan matematika

Kompilasi program tersebut dan jalankan, Anda akan mendapatkan: > 3 Mengapa 3? Bukankah 1 + 2 = 3 > 3 * 3 = 9 > 9 - 4 = 5? Jawabannya, Pascal

mengerti apa yang disebut dengan operator precedence (tingkatan operator) yang

biasa digunakan pada kalkulator ilmiah, di mana operator yang memiliki tingkatan

lebih tinggi akan didahulukan operasinya. Tabel 2.1 menunjukkan operator dan

tingkatannya di mana angka yang lebih rendah menunjukkan tingkatan yang lebih

tinggi. Maka dari itu, Pascal memahami perhitungan matematika di atas sebagai

1+(2*3)-4. Jika yang diinginkan adalah (1+2)*3-4, gunakan tanda kurung yang

sesuai. Sebaiknya, demi menghindari hasil yang tidak diinginkan, selalu gunakan

tanda kurung dalam setiap perhitungan yang harus didahulukan.

16

Tingkatan Operator Kategori 1 not @ Operator Tunggal 2 * / div mod and shl shr as Operator Perkalian 3 + - or xor Operator Penjumlahan 4 = < > = in is Operator Relasi

Tabel 2.1 Operator dan tingkatannya

Selanjutnya, kita akan mempelajari program tersebut. Bagian yang berubah

dari program sebelumnya hanyalah pada argumen prosedur WriteLn. Seperti yang

telah dijelaskan, WriteLn dapat menerima argumen dalam jumlah dan tipe yang

bervariasi. Dalam hal ini argumen yang diberikan ada 2, dipisahkan dengan ,

(tanda koma). Argumen yang pertama sama seperti sebelumnya, berupa string. Sedangkan argumen kedua berupa ekspresi aritmatika yang memberikan nilai

berupa angka.

Angka dalam komputer tidaklah seabstrak angka dalam matematika. Ada

batasan-batasan yang harus dipenuhi agar kita mendapatkan hasil perhitungan

yang sesuai secara efisien. Pertama, angka dalam komputer bersifat TERBATAS.

Walaupun ada beberapa pustaka yang memungkinkan kita menulis angka

berapapun besarnya namun biasanya perhitungannya lebih lambat dan

menggunakan memori lebih besar. Karenanya, pustaka semacam itu biasanya

hanya digunakan di lingkungan yang membutuhkan ketelitian tinggi.

Pascal mendefinisikan dua tipe angka, yaitu Integer dan Real. Integer

adalah tipe data yang memuat bilangan bulat, sementara Real dapat juga memuat

pecahan. Tabel 2.2 menunjukkan tipe Integer yang tersedia, luas jangkauan, dan

ukurannya dalam memori, sementara tabel 2.3 menunjukkan hal yang sama untuk

Real. Untuk ekspesi aritmatika langsung (tanpa variabel), kompilator akan secara

otomatis menggunakan tipe data yang sesuai. Cobalah bereksperimen dengan

17

perhitungan-perhitungan lainnya! Jika ada perhitungan yang tidak sesuai, lihatlah

tabel tingkatan operator.

Jika Anda mencoba perhitungan yang melibatkan Real (baik operand maupun hasilnya) dan menuliskannya dengan prosedur Write(Ln), maka Anda akan mendapatkan hasil yang kelihatannya tidak lazim. Misalnya, jika Anda

menulis WriteLn(1/4) maka yang tampil di layar adalah > 2.5000000000000000E-0001 Ini adalah notasi ilmiah yang merupakan default keluaran untuk Real. Jika Anda ingin hasil yang lebih mudah dibaca, maka Anda harus mem-format-nya dengan

cara memberikan : (titik dua) diikuti dengan lebar minimum keluaran (rata

kanan) dan titik dua diikuti dengan jumlah desimal yang Anda butuhkan (otomatis

dibulatkan). Misalnya WriteLn(3/8:5:2) akan memberikan hasil

0.38 (pembulatan dari 0.375) Perhatikan adanya spasi di depan! Karena kita meminta lebar minimum 5,

sedangkan keluarannya hanya 4 karakter (0.38) maka akan ditambahkan spasi

sampai panjang keluaran sama dengan lebar minimum. Karena rata kanan, maka

spasi akan ditambahkan di depan. Hal ini juga berlaku untuk tipe data lain yang

bisa diterima Write(Ln), namun hanya titik dua pertama yang diperlukan (jika Anda memaksa, akan terjadi compile error) karena tipe data lain tidak memiliki

bagian desimal. Untuk hal ini, Anda dipersilakan mencoba sendiri.

Kuis:

1. Mengapa pada kalimat WriteLn('1+2*3-4 = ',1+2*3-4);, argumen kedua dicetak sebagai 3, bukan 1+2*3-4 seperti argumen pertama?

2. Berapa jumlah spasi yang akan ditambahkan untuk perintah

WriteLn(2/7:7:3)?

18

Tipe Jangkauan Ukuran (dalam Bytes) Byte 0 .. 255 1 ShortInt -128 .. 127 1 SmallInt -32768 .. 32767 2 Word 0 .. 65535 2 Integer SmallInt, LongInt, atau Int64 2, 4, atau 8 Cardinal Word, LongWord, atau QWord 2, 4, atau 8 LongInt -2147483648 .. 2147483647 4 LongWord 0 .. 4294967295 4 Int64 -9223372036854775808 .. 9223372036854775807 8 QWord 0 .. 18446744073709551615 8

Tabel 2.2 Tipe Integer, luas jangkauan, dan ukurannya dalam memori

Tipe Jangkauan Digit Penting Ukuran

(dalam Bytes) Real tergantung platform ??? 4 atau 8 Single 1.5E-45 .. 3.4E38 7-8 4 Double 5.0E-324 .. 1.7E308 15-16 8 Extended 1.9E-4932 .. 1.1E4932 19-20 10 Comp -2E64+1 .. 2E63-1 19-20 8 Currency -922337203685477.5808 ..

922337203685477.5807 19 8

Tabel 2.3 Tipe Real, luas jangkauan, dan ukurannya dalam memori

19

Masukan dan Keluaran

Masukan sederhana (tanpa kemungkinan error)

Sejauh ini, program yang kita buat selalu menghasilkan keluaran yang

sama. Jika ingin hasil yang berbeda, maka program harus diubah dan dikompilasi

ulang. Hal ini tentu sangat tidak efisien, sebab tidak mungkin kita selalu menulis

ulang program hanya karena masukannya berubah. Untuk itu, komputer

menyediakan fasilitas masukan dan keluaran untuk program. Sebagai contoh, lihat

program 3.1.

1 program Halo2; 2 3 var 4 Nama: String; 5 begin 6 Write('Siapa nama Anda? '); 7 ReadLn(Nama); 8 WriteLn('Halo, ',Nama,'!'); 9 end. 10

Program 3.1 Halo dengan masukan

Keterangan:

String dalam Pascal adalah tipe data sekaligus kata kunci, karena itu selain dicetak tebal, penulisannya juga menggunakan huruf kapital.

Program ini adalah modifikasi dari program 1.1, di mana ada penambahan 1

struktur dan 2 pemanggilan prosedur baru. Struktur baru yang ditambahkan adalah

blok var pada baris ke-3, yang menandakan deklarasi variabel.

Variabel adalah tempat dalam memori yang bisa kita baca atau tulis.

Sebelum bisa digunakan, variabel HARUS dideklarasikan17 terlebih dahulu (Lihat

kembali bagan 1.1 sebagai referensi bagaimana variabel dideklarasikan). Variabel 17 Beberapa bahasa pemrograman memperbolehkan penggunaan variabel tanpa deklarasi, misalnya Ruby & Lua

20

dalam program ini berjumlah 1, bernama Nama dan bertipe string. Tipe string dapat memiliki batas maksimum, yang jika tidak ditulis dianggap 255. Cara

membatasi panjang string adalah dengan menuliskan sebuah Integer non-negatif dalam kurung siku setelah kata string (Misalnya var s: String[10]).

Kemudian, pada baris ke-6 terdapat pemanggilan prosedur Write ketimbang

WriteLn. Hal ini dimaksudkan agar tidak terjadi penambahan baris setelah

pencetakan.

Baris berikutnya, terdapat pemanggilan prosedur ReadLn. Ini adalah

prosedur internal lain yang melakukan hal yang berkebalikan dari WriteLn, yaitu

membaca masukan dari pengguna. Masukan dapat berupa apa saja, dan diakhiri

dengan Enter. Masukan yang diterima ReadLn selalu bertipe string. Argumen yang dapat kita berikan harus bertipe Char18, Integer, Real, String atau PChar

(tipe data PChar akan dibahas kemudian). Jika variabel yang kita berikan sebagai

argumen untuk ReadLn bukan string, maka akan diubah ke tipe yang sesuai. Setelah prosedur selesai, variabel Nama akan berisi masukan dari pengguna (tidak termasuk Enter). Baris berikutnya mencetak Halo, diikuti dengan ISI dari

variabel Nama (plus ! untuk menandakan kalimat sapaan). Contoh jalannya

program: > Halo2.exe > Siapa nama Anda? Mario > Halo, Mario! > Halo2.exe > Siapa nama Anda? 255 > Halo, 255! Variabel bertipe string bisa memuat apa saja, bahkan ekspresi matematika. Karena itu, tidak akan terjadi error apa-apa. Namun, ekspresi tersebut akan ditulis

persis seperti kita menulisnya ketimbang hasil perhitungannya.

Kuis:

18 Char adalah tipe data dasar yang membentuk String. Faktanya, String adalah untaian Char.

21

Mengapa ekspresi matematika yang kita tulis tersebut tidak dievaluasi terlebih

dahulu sebelum dicetak?

Masukan dengan kemungkinan error

Modifikasi program 3.1 hingga menjadi program 3.2. Lalu seperti biasa,

kompilasi dan jalankan. Ikuti dan isilah dengan logis. Misalnya: > Halo3.exe > Siapa nama Anda? Mario

1 program Halo3; 2 3 var 4 Nama: String; 5 Umur: Byte; 6 begin 7 Write('Siapa nama Anda? '); 8 ReadLn(Nama); 9 WriteLn('Halo, ',Nama,'!'); 10 Write('Berapa umur Anda? '); 11 ReadLn(Umur); 12 WriteLn('Tidak disangka umur Anda ',Umur,' tahun!'); 13 end.

Program 3.2 Masukan dengan kemungkinan error

> Halo, Mario! > Berapa umur Anda? 20 > Tidak disangka umur Anda 20 tahun! Sekarang, jalankan lagi dan ketika program bertanya tentang umur, coba jawab

dengan karakter alfabet atau suatu kalimat. Misalnya: > Berapa umur Anda? Nggak tahu Anda mungkin akan mendapatkan: Runtime error 106 at $00401424 $00401424 $004069F0 atau sejenisnya. Menurut dokumentasi Free Pascal, Runtime error19 106 berarti

Invalid numeric format. Yaitu error yang terjadi ketika program meminta angka 19 Error yang terjadi ketika program sedang berjalan. Error semacam ini lebih sulit ditangani ketimbang compile error, karena kemunculannya bisa tidak terduga

22

sebagai masukan, namun yang terbaca adalah karakter non-angka. Error ini dipicu

oleh kesalahan pada ReadLn(Umur) di mana Umur didefinisikan sebagai variabel bertipe Byte, namun masukan yang kita berikan adalah Nggak tahu (atau masukan non-angka lainnya) yang tidak dapat direpresentasikan nilainya dalam

Byte. Lalu, bagaimana kita mengatasi error di atas? Tidak mungkin kita bisa

memastikan bahwa masukan yang diberikan pengguna selalu benar. Setelah

mempelajari loop (dan fungsi), cobalah untuk mengatasinya. Sampai saat itu,

pastikan saja bahwa masukan yang diberikan selalu benar.

23

Pemberian Nilai

Pemberian nilai pada saat eksekusi

Selain melalui masukan, variabel dengan tipe data tertentu dapat kita beri

nilai secara eksplisit. Yang termasuk kategori ini adalah seluruh tipe data dasar

(Integer, Real, Char, dan Boolean20) dan beberapa tipe terstruktur (String, PChar,

Set21). Operator pemberian nilai dalam bahasa Pascal adalah := (tanpa kutip), jangan tertukar dengan = yang merupakan operator relasi). Program 4.1 berikut menunjukkan pemberian nilai yang valid dalam Pascal.

1 program BeriNilai; 2 3 var 4 i: Integer; 5 r: Real; 6 c: Char; 7 b: Boolean; 8 s: String; 9 p: PChar; 10 sb: set of Byte; 11 begin 12 i:=10; 13 r:=3.14; 14 c:='a'; 15 b:=false; 16 s:='aku'; 17 p:='aku'; 18 sb:=[1,2,5]; 19 end. 20

Program 4.1 Pemberian nilai pada variabel

Cobalah mengubah-ubah nilai di atas, bila Anda mendapat compile error, periksa

apakah nilai yang Anda berikan memiliki tipe data yang sesuai dengan

variabelnya. Untuk sementara, abaikan dahulu Boolean, PChar, dan Set.

20 Tipe data yang hanya memiliki dua nilai, yaitu benar (true) atau salah (false). 21 Tipe data ini sangat berguna dalam menyelesaikan masalah yang berkaitan dengan himpunan, baik dalam matematika maupun masalah umum.

24

Pemberian nilai tidak harus berupa nilai mutlak, namun dapat juga berupa

ekspresi. Sebagai contoh, lihat program 4.2.

1 program BeriNilai2; 2 3 var 4 i: Integer; 5 r: Real; 6 c: Char; 7 s: String; 8 begin 9 i:=1+2*3-4; 10 r:=(5+6)/7; 11 c:=Chr(65); 12 s:='Nama'+' saya '+'Joko'; 13 end. 14

Program 4.2 Pemberian nilai dengan ekspresi

Pemberian nilai pada saat deklarasi (inisialisasi)

Selain saat eksekusi, kita juga dapat memberikan nilai pada saat deklarasi

variabel (atau disebut juga inisialisasi). Kebalikan dari sebelumnya, tipe data

Array (larik) dan Record (rekaman) dapat diinisialisasi. Berikut contoh program

yang melakukan inisialisasi variabel.

1 program BeriNilai2; 2 3 var 4 i: Integer = 1; 5 r: Real = 2.5; 6 c: Char = 'c'; 7 s: String = 'Nama saya Joko'; 8 a: array [1..3] of Byte = (1,3,6); 9 r: record 10 x,y: Byte; 11 end = (x:1;y:2); 12 begin 13 end. 14

Program 4.3 Pemberian nilai melalui inisialisasi

25

Sekali lagi, untuk sementara abaikan dahulu tipe data Array dan Record. Program di atas hanya untuk menunjukkan bahwa tipe data terstruktur dapat juga diinisialisasi.

Tugas 1

Buatlah sebuah program yang meminta masukan 5 buah variabel bertipe

ShortInt, kemudian tuliskan nilai masing-masing, jumlah, dan rata-ratanya! Tuliskan dengan rapi (rata kiri-kanan dan = yang berada pada satu kolom) di mana untuk rata-rata, tuliskan 3 angka desimalnya! Contoh keluaran: > Angka 1 = 10 > Angka 2 = -15 > Angka 3 = -7 > Angka 4 = 22 > Angka 5 = 3 > Jumlah = 13 > Rata-rata = 2.600 Asumsikan masukan memiliki jangkauan -100 sampai 100.

26

Perintah Bercabang

Dalam program komputer, tidak seluruh perintah yang kita tulis harus

dijalankan. Ada kalanya, kita perlu mengeksekusi perintah hanya apabila suatu

kondisi dipenuhi. Hal ini dapat dilakukan dengan perintah bercabang (branching).

Dalam bahasa Pascal, terdapat dua perintah bercabang, yaitu if dan case.

if ... then ... else

Perhatikan program 5.1 berikut.

1 program IfThenElse; 2 3 var 4 b: Byte; 5 begin 6 Write('Berapa 1+1? '); 7 ReadLn(b); 8 if b=2 then 9 WriteLn('Benar!') 10 else 11 WriteLn('Salah!'); 12 end. 13

Program 5.1 Perintah bercabang ifthenelse

Fokuskan perhatian Anda pada baris ke-8 sampai 11. Alur program pada bagian

tersebut dapat dijelaskan sebagai berikut:

1. Periksa ekspresi boolean pada bagian if (dalam hal ini, b=2) 2. Jika bernilai true, lakukan perintah pada bagian then (dalam hal ini,

WriteLn('Benar!')) 3. Jika bernilai false, lakukan perintah pada bagian else (dalam hal ini

WriteLn('Salah!')) Ekspresi boolean merupakan ekspresi yang hanya mengembalikan nilai

true (benar) atau false (salah). Ekspresi ini dapat diperoleh dengan menggunakan operator relasi (lihat tabel 2.1) dan operator logika. Yang termasuk

27

operator logika pada Pascal adalah and, or, not, dan xor. Pascal menggunakan ke-4 operator (sekaligus kata kunci) tersebut dalam dua konteks yang berbeda,

yaitu sebagai operator logika dan operator bitwise (dipelajari kemudian), namun

dengan tingkatan yang sama. Jadi, tingkatan operator pada tabel 2.1 berlaku juga

di sini. Operasi logika dalam pemrograman sama dengan operasi logika pada

matematika. Tabel 3.1 menunjukkan tabel kebenaran dalam operasi logika.

AND benar salah

benar benar salah

salah salah salah

OR benar salah

benar benar benar

salah benar salah

XOR benar salah

benar salah benar

salah benar salah

Tabel 3.1 Tabel kebenaran operasi logika

Untuk operasi not, tinggal balikkan saja nilainya (benar > salah, salah > benar). Kembali ke ekspresi boolean, ekspresi ini bisa diberikan sebagai nilai untuk

variabel bertipe boolean.

Catatan

Hati-hati saat melakukan operasi boolean yang rumit! Perhatikan bahwa tanda

kurung ( ) memiliki tingkatan tertinggi dari semua operator, diikuti operator

logika, dan yang terrendah operator relasi. Maka, terjemahan yang benar dari a

kurang dari 5 atau a lebih dari 10 adalah (a10). Jika Anda hanya menulis a10, kompilator akan melihatnya sebagai a10 yang akan mengakibatkan compile error.

Setelah mempelajari ekspresi boolean, bentuk perintah bercabang if dapat dengan mudah dipahami. Kembali ke program, bagian else tidak harus ada. Bagian tersebut diperlukan jika percabangan memiliki perintah alternatif. Sebagai

contoh, misalkan jika pengguna memberi masukan yang salah, maka program

28

akan memberi nilai yang telah ditentukan (default). Contohnya dapat dilihat pada

program 5.2.

1 program IfTanpaElse; 2 3 var 4 b: Byte; 5 begin 6 Write('Masukkan satu angka antara 1 s/d 5 (default: 1): '); 7 ReadLn(b); 8 if (b5) then b:=1; 9 WriteLn('Angka yang Anda masukkan adalah ',b); 10 end. 11

Program 5.2 If tanpa else

Gunakan ekspresi boolean yang telah Anda pelajari untuk memahami program ini.

Kembali ke program 5.1, perhatikan pada baris ke-9 bahwa tidak ada titik koma

pada akhir baris. Hal ini dikarenakan konstruksi if then else merupakan satu kesatuan.

Perintah yang terdapat pada bagian then dan else pada dasarnya tidak dapat berjumlah lebih dari satu. Namun, kita dapat memberikan lebih dari satu

perintah dengan menggunakan kalimat gabungan (compound statement) atau yang

sebelumnya kita sebut blok, yaitu berupa kumpulan kalimat yang dilingkupi oleh

begin dan end. Sebagai contoh, lihat program 5.3.

Konstruksi ini dapat pula dikumpulkan (nested), artinya pada bagian then maupun else, perintah yang diberikan dapat berupa if then else lagi. Anda diberikan kebebasan untuk membuat contoh programnya.

Kuis:

1. Apa hasil dari true and not false or true xor false? 2. Bagaimana kompilator melihat ekspresi tersebut?

29

1 program IfThenElse2; 2 3 var 4 b: Byte; 5 begin 6 Write('Berapa 1+1? '); 7 ReadLn(b); 8 if b=2 then begin 9 WriteLn('Benar!'); 10 WriteLn('Jawabannya ',b); 11 end else begin 12 WriteLn('Salah!'); 13 WriteLn('Jawaban yang benar ',b); 14 end; 15 end. 16

Program 5.3 If dengan compound statement

Catatan

Hati-hati pada penggunaan nested if then else! Perhatikan potongan program berikut: if a then if b then LakukanSesuatu else LakukanYangLain; Meskipun kelihatannya else merupakan alternatrif dari if a then, namun sebenarnya kompilator melihatnya sebagai: if a then if b then LakukanSesuatu else LakukanYangLain; Aturan sebenarnya dalam hal ini adalah else dipasangkan pada if pertama yang belum dipasangkan. Jika Anda ingin kode berjalan seperti pada bentuk yang

pertama, maka pemberian begin end pada bagian then dari if yang pertama wajib dilakukan. Saat Anda ragu, sebaiknya tuliskan saja. Dengan aturan tersebut,

maka potongan program yang benar adalah:

30

if a then begin if b then LakukanSesuatu; end else LakukanYangLain;

case ... of

Perintah bercabang kedua adalah case of. Perhatikan contoh program berikut.

1 program CaseOf; 2 3 var 4 Sudut: Word; 5 begin 6 Write('Berapa besar sudut pada segitiga sama sisi? '); 7 ReadLn(Sudut); 8 case Sudut of 9 0..59: WriteLn('Terlalu kecil!'); 10 60 : WriteLn('Benar!'); 11 else WriteLn('Terlalu besar!'); 12 end; 13 end. 14

Program 5.4 Perintah bercabang caseof

Perhatikan baris 8 12! Cara kerja case of pada program tersebut kurang lebih sebagai berikut:

1. Periksa nilai ekspresi di antara kata kunci case dan of (dalam program: nilai variabel Sudut)

2. Periksa nilai di antara kata kunci of dan simbol titik dua (disebut kasus, dalam program: 0..59). Jika tipenya berupa: - Nilai ordinal22, bandingkan nilai pada bagian 1 dengan nilai tersebut

(menggunakan operator =)

22 Tipe data yang banyaknya bisa dihitung dan nilai-nilainya bisa diurutkan, memiliki nilai terkecil dan juga nilai terbesar

31

- Subjangkauan23 (subrange), tentukan apakah nilai pada bagian 1

termasuk di dalamnya (menggunakan operator in) 3. Jika hasil perbandingan bernilai true, lakukan perintah setelah titik dua di

belakang nilai yang tersebut. Jika false, ulangi langkah 2 untuk nilai-nilai berikutnya (dalam program: 60)

4. Jika hasil perbandingan selalu false dan pada bagian terakhir ada kata kunci else (atau otherwise24) pada bagian terakhir, langsung lakukan perintah yang ada setelahnya

if then else dan case of sebenarnya mirip, berikut adalah kesamaan-kesamaan di antara keduanya.

1. Perintah untuk setiap kasus pada dasarnya hanya dapat menampung satu

kalimat. Namun sama seperti pada if, Anda dapat menggunakan kalimat gabungan untuk memberikan perintah yang memiliki lebih dari satu kalimat.

2. Sama seperti if, konstruksi case dapat dikumpulkan. Artinya dalam salah satu atau beberapa (atau bahkan semua) kasusnya, perintah yang diberikan berupa

case juga. Selain kesamaan, tentu ada perbedaan (kekurangan/kelebihan) di antara

keduanya. Kekurangan case of adalah ekspresi yang dapat digunakan terbatas pada tipe ordinal (dan subjangkauan pada setiap kasusnya), karena pembandingan

hanya dilakukan dengan menggunakan operator = (dan in untuk subjangkauan). Pada if, seluruh operator relasi dapat digunakan. Sedangkan kelebihan case of dibandingkan if then else secara umum ada 2, yang pertama adalah penulisan kode yang lebih pendek. Hal ini dikarenakan ekspresi yang akan

dibandingkan (yang terletak diantara case dan of) hanya perlu ditulis 1 kali. Kelebihan yang kedua dan lebih mencolok adalah ketika ekspresi yang akan

dibandingkan bukan ekspresi sederhana. Perhatikan kedua potongan program

berikut.

23 Sub-tipe dari suatu tipe ordinal. Didefinisikan sebagai batas bawah dan batas atas dari suatu jangkauan nilai 24 Kata kunci ini didefinisikan dalam Extended Pascal, namun sebagian besar kompilator lebih memilih menggunakan else walaupun otherwise tetap diterima

if i*(5+4) div 3=1 then LakukanA else if i*(5+4) div 3=2 then LakukanB else if i*(5+4) div 3 in [3..5] then LakukanC else LakukanD;

case i*(5+4) div 3 of 1 : LakukanA; 2 : LakukanB; 3..5: LakukanC; else LakukanD; end;

Kedua potongan program tersebut ekivalen, namun ada yang sedikit berbeda

dalam kerjanya. Pada potongan program yang pertama, ekspresi i*(5+4) div 3 harus dihitung 3 kali, sementara pada potongan program yang kedua, hanya 1 kali.

Hal ini akan mempengaruhi waktu eksekusi program. Program yang lebih cepat

tentu lebih baik (asalkan hasilnya tetap benar).

33

Bilangan Acak

Pernahkah Anda bermain game kartu? Apakah setiap kali bermain, Anda

selalu mendapatkan susunan kartu yang sama? Tentu tidak, bukan? Bagaimana

cara komputer melakukannya?

Kompilasi dan jalankan program berikut, Anda akan mendapat hasil yang

berbeda tiap kali menjalankannya!

1 program Acak; 2 3 var 4 b: Byte; 5 begin 6 Randomize; 7 WriteLn( 8 Random,' ', // 0.0 .. 0.999...9 9 Random(100)+1,' ', // 1 .. 100 10 Random(256) // 0 .. 255 11 ); 12 end. 13

Program 6.1 Bilangan acak

Komputer sebenarnya tidak memiliki kemampuan untuk menghasilkan bilangan

acak. Setiap bahasa pemrograman memiliki cara masing-masing untuk

melakukannya. Dari sekian banyak algoritma, yang paling sering digunakan

adalah dengan melakukan lompatan dari satu lokasi memori ke lokasi yang lain

dan mengambil nilai yang terdapat di sana. Jarak lompatan ditentukan oleh seed

yang kita tentukan sendiri. Namun, program akan menghasilkan keluaran yang

sama jika seed-nya sama. Masalah ini diatasi dengan menggunakan timer

(biasanya bagian detik saja) sebagai seed sebelum melakukan lompatan. Dalam

Pascal, hal ini dapat dilakukan oleh prosedur Randomize. Sedangkan lompatan dilakukan oleh fungsi Random yang meminta 1 argumen bertipe Integer, dan menghasilkan nilai antara 0 dan argumen tersebut (termasuk 0, tidak termasuk

argumen). Atau fungsi alternatif yang memiliki nama yang sama namun tidak

34

meminta argumen, menghasilkan nilai Real antara 0 dan 1 (termasuk 0, tidak termasuk 1).

Tugas 2

1. Buatlah sebuah program yang menanyakan perhitungan matematika sederhana

(penjumlahan, pengurangan, perkalian, pembagian) dengan dua operand (batas

nilai operand 1 100). Kemudian, berikan tanggapan atas jawaban pengguna

(respon benar jika jawabannya benar dan juga sebaliknya) beserta jawaban

yang benar. Soal yang diberikan tidak boleh sama setiap kali program

dijalankan!

Keterangan: Untuk pembagian, ambil nilai bulatnya saja. Misal: 7 / 3 = 2

2. Jika Anda menggunakan konstruksi if, buatlah versi case-nya! Sebaliknya jika Anda menggunakan case, buatlah versi if-nya!

35

Pengulangan 1: Iterasi

Apakah Anda pernah merasa bahwa program yang Anda buat sebenarnya

memiliki langkah-langkah yang berulang? Misalnya, bagaimana Anda mencetak

daftar 2n untuk 1 < n < 5? Asumsikan Anda menggunakan fungsi Power dari unit Math, mungkin Anda akan menuliskan:

1 program DuaPangkatN; 2 3 uses 4 Math; 5 6 begin 7 WriteLn(Power(2,1)); 8 WriteLn(Power(2,2)); 9 WriteLn(Power(2,3)); 10 WriteLn(Power(2,4)); 11 WriteLn(Power(2,5)); 12 end. 13

Program 7.1 Dua pangkat n tanpa pengulangan

Bagaimana jika kebutuhan Anda meningkat? Misalkan sekarang 0 < n < 99. Jika

Anda melakukan hal yang sama seperti di atas, berarti Anda harus menambahkan

95 baris lagi! Program Anda akan menjadi panjang dan sulit dibaca. Belum lagi

kemungkinan salah ketik yang sangat besar. Bagaimana caranya supaya

perubahan yang Anda lakukan seminimal mungkin? Dengan pengulangan

(looping), hal ini dapat dengan mudah dilakukan. Pengulangan dibagi menjadi

dua, yaitu iterasi dan rekursi. Dalam bab ini, kita akan mempelajari iterasi atau

pengulangan iteratif. Rekursi akan kita pelajari dalam prosedur dan fungsi.

Dalam pemrograman, dikenal tiga jenis pengulangan iteratif, yaitu:

1. Pengulangan tetap (jumlah pengulangan dapat dihitung dahulu)

2. Pre-test (pemeriksaan dilakukan sebelum pengulangan)

3. Post-test (pemeriksaan dilakukan setelah pengulangan)

36

Pascal mengimplementasikan ketiga jenis pengulangan tersebut dengan tiga

konstruksi berbeda. Kita akan mempelajarinya satu per satu.

for .. to / downto .. do

Pengulangan tetap dalam Pascal diwakili oleh konstruksi for, di mana pengulangan dikendalikan oleh sebuah variabel (disebut loop variable atau

index25) mulai dari suatu nilai awal hingga nilai akhirnya. Kita akan menggunakan

permasalahan sebelumnya sebagai contoh.

1 program DuaPangkatNFor; 2 3 uses 4 Math; 5 6 var 7 n: Byte; 8 begin 9 for n:=1 to 5 do 10 WriteLn(Power(2,n)); 11 end. 12

Program 7.2 Dua pangkat n dengan pengulangan tetap

Sekarang, Anda hanya perlu mengganti nilai n pada bagian for untuk memperoleh hasil yang berbeda. Pada permasalahan di atas, ketika n berubah dari

1 < n < 5 ke 0 < n < 99, yang perlu Anda lakukan hanya mengganti for n:=1 to 5 do dengan for n:=0 to 99 do

Cara kerja for kurang lebih sebagai berikut: 1. Inisialisasi index dengan nilai awalnya

2. Periksa apakah nilai index sekarang lebih besar dari nilai akhirnya, jika:

a. Ya, hentikan iterasi

25 Hal ini dikarenakan for sering digunakan untuk menginisialisasi array yang sulit jika diinisialisasi secara manual. Misalnya, untuk membuat tabel trigonometri.

37

b. Tidak, jalankan perintah setelah kata kunci do lalu tambahkan nilai index sebanyak 1

3. Ulangi langkah ke-2 dan 3 hingga iterasi selesai (kasus 2a)

Catatan

Free Pascal tidak mengizinkan adanya kalimat yang mengubah nilai index dalam

perintah setelah do. Hal ini akan menjadikan pengulangan menjadi tidak tetap sehingga tidak jelas kapan iterasi akan selesai.

Turbo Pascal dan beberapa kompilator Mac Pascal membolehkan hal ini,

walaupun dianggap merusak struktur for.

Bagaimana jika hasil yang ingin diperoleh disusun terbalik? Untuk tujuan

ini, Pascal memiliki tipe for yang nilai index-nya berkurang dari satu iterasi ke iterasi berikutnya.

Sama seperti konstruksi Pascal yang lain, for dapat dikumpulkan dan

perintah setelah do dapat berupa kalimat gabungan.

while .. do

Pre-test dalam Pascal diwakili oleh konstruksi while. Konstruksi ini hanya dikendalikan oleh kondisi yang diberikan, tanpa variabel tambahan. Program

sebelumnya dapat pula dibuat versi while-nya seperti pada program 7.3 berikut.

1 program DuaPangkatNWhile; 2 3 uses 4 Math; 5 6 var 7 n: Byte; 8 begin 9 n:=1; 10 while n5 do begin 11 WriteLn(Power(2,n)); 12 Inc(n); // Tambahkan nilai n sebanyak 1 13 end; 14 end. 15

38

Program 7.3 - Dua pangkat n dengan pre-test

Cara kerjanya sangat sederhana:

Periksa kondisi di antara kata kunci while dan do, jika hasilnya: a. False, hentikan iterasi

b. True, lakukan perintah setelah kata kunci do kemudian lakukan lagi langkah di atas

Perhatikan bahwa while tidak akan mengubah kondisi yang diberikan secara otomatis. Kita harus secara eksplisit mengubahnya dalam salah satu kalimat dalam

perintah setelah kata kunci do. Maka pada program di atas, diperlukan penambahan nilai n (melalui Inc(n)) pada baris ke-12.

Catatan

Ketika melakukan konversi antara for dan while, perhatikan bahwa for menambah nilai index SETELAH melakukan perintah. Untuk itu, pada while penambahan index harus selalu dilakukan pada kalimat terakhir.

repeat .. until

Jenis iterasi yang terakhir, yaitu post-test, dalam Pascal diwakili oleh

konstruksi repeat. Konstruksi ini mirip dengan while, hanya saja terdapat dua perbedaan dari while, yaitu: 1. Tidak diperlukan compound statement untuk perintah yang memiliki lebih dari

satu kalimat. Hal ini dikarenakan repeat until sendiri sudah membentuk blok (anggap repeat sebagai begin dan until sebagai end)

2. Cara kerjanya terbalik dari while (pemeriksaan dilakukan setelah perintah dieksekusi)

Untuk lebih memahami, berikut cara kerja repeat. Lakukan perintah di antara kata kunci repeat dan until, kemudian periksa kondisi setelah kata kunci until. Jika hasilnya:

39

a. False, ulangi langkah di atas

b. True, hentikan iterasi

Perhatikan bahwa repeat akan melakukan perintah hingga kondisi terpenuhi, sementara while akan melakukan perintah hingga kondisi TIDAK terpenuhi. Satu hal lagi yang perlu diperhatikan adalah karena repeat melakukan pemeriksaan setelah melakukan perintah, maka setidak-tidaknya perintah akan dilakukan satu

kali. Sementara pada while, perintah bisa saja sama sekali tidak dilakukan. Program yang sama dengan konstruksi repeat dapat dilihat pada program 7.4 berikut.

1 program DuaPangkatNRepeat; 2 3 uses 4 Math; 5 6 var 7 n: Byte; 8 begin 9 n:=1; 10 repeat 11 WriteLn(Power(2,n)); 12 Inc(n); // Tambahkan nilai n sebanyak 1 13 until n=5; 14 end. 15

Program 7.4 Dua pangkat n dengan post-test

Kuis:

1. Jika mengikuti cara kerja masing-masing, manakah yang hubungannya lebih

dekat antara for while dan for repeat? Jelaskan! 2. Dari contoh di atas, for selalu dapat direpresentasikan sebagai while dan/atau

repeat. Apakah hal yang sama berlaku untuk kebalikannya? Mengapa?

40

Tugas 3

Iterasi merupakan elemen penting pemrograman imperative. Kuasailah dengan

baik dan ujilah dengan mengerjakan tugas berikut. Buatlah program yang

meminta input sebuah Byte kemudian buatlah struktur-struktur berikut berdasarkan input tersebut!

a. Panah

Input 2: Input 3: Input 4:

* * * ** ** ** * *** *** ** **** * *** ** *

b. Kotak

Input 2: Input 3: Input 4:

** *** **** ** * * * * *** * * ****

c. Berlian (wajik)

Input 2: Input 3: Input 4:

* * * ** ** ** * *** *** ** **** * *** ** *

d. Silang

Input 2: Input 3: Input 4:

** * * * * ** * ** * * ** * *

Jika Anda telah berhasil dengan satu jenis iterasi, coba gunakan yang lain. Untuk

lebih menguji kemampuan Anda, gabungkan antara dua atau lebih jenis iterasi.

41

Ujian 1

Buatlah program tebak angka dengan spesifikasi sebagai berikut:

1. Program meminta nama pemain

2. Program meminta nilai minimum dan maksimum tebakan (antara 1 1000).

Jika nilai yang dimasukkan diluar jangkauan atau nilai minimum lebih besar

dari maksimum, beri pesan kesalahan dan ulangi permintaan

3. Program meminta berapa kali pemain boleh menebak sebelum dinyatakan

gagal (minimum 3 kali, maksimal 15 kali). Jika nilai yang dimasukkan diluar

jangkauan, beri pesan kesalahan dan ulangi permintaan

4. Nilai tebakan harus berbeda setiap kali program dijalankan

5. Untuk setiap tebakan, tuliskan banyaknya kesempatan yang masih tersisa

6. Untuk setiap tebakan, jika nilai yang dimasukkan pemain:

a. > nilai tebakan, beri pesan bahwa nilai yang dimasukkan terlalu besar

kemudian kurangi kesempatan yang tersisa

b. < nilai tebakan, beri pesan bahwa nilai yang dimasukkan terlalu kecil

kemudian kurangi kesempatan yang tersisa

c. = nilai tebakan, akhiri permainan dengan menampilkan pesan yang berisi

nilai tebakan yang benar, berapa kali pemain menebak, nama pemain,

dan grade-nya

d. Di luar jangkauan, beri pesan kesalahan (JANGAN kurangi kesempatan!)

7. Grade ditentukan dari dari kesempatan yang tersisa, jika

a. > nilai yang dimasukkan (dibulatkan*) di awal permainan, A

b. > nilai yang dimasukkan (dibulatkan) di awal permainan, B

c. > nilai yang dimasukkan (dibulatkan) di awal permainan, C

d. < nilai yang dimasukkan (dibulatkan) di awal permainan, D

8. Jika kesempatan=0, akhiri permainan dengan menampilkan pesan yang berisi

nilai tebakan yang benar dan nama pemain

*: Gunakan fungsi internal Round untuk membulatkan

42

Subprogram

Setelah mempelajari dasar-dasar pemrograman imperative, sekarang kita

akan menggabungkannya dengan konsep yang menjadi basis pemrograman

prosedural, yaitu subprogram, dalam bentuk prosedur dan fungsi.

Prosedur

Prosedur merupakan langkah pertama dalam modularisasi26. Program dibagi

menjadi bagian-bagian kecil yang saling berhubungan, namun dengan tugas yang

independen, sehingga (program utama) tidak akan menjadi terlalu panjang, karena

sebagian besar hanya merupakan pemanggilan prosedur. Contoh penggunaan

prosedur dapat dilihat pada program berikut.

1 program Prosedur; 2 3 uses 4 SysUtils, // DateOf, Now 5 DateUtils; // EncodeDateTime, YearsBetween 6 7 procedure HitungUmur(Tgl,Bln: Byte; Thn: Word); 8 begin 9 WriteLn('Umur Anda sekarang ', 10 YearsBetween( 11 EncodeDateTime(Thn,Bln,Tgl,0,0,0,0), 12 DateOf(Now) 13 ), 14 ' tahun.'); 15 end; 16 17 var 18 Tanggal,Bulan: Byte; 19 Tahun: Word; 20 begin 21 Write('Tanggal, bulan, dan tahun berapa '+ 22 'Anda lahir (misal: 25 5 1988)? '); 23 ReadLn(Tanggal,Bulan,Tahun); 24 HitungUmur(Tanggal,Bulan,Tahun); 25 end. 26

Program 8.1 Prosedur menghitung umur

26 Teknik pembuatan program yang mudah dipertahankan maupun dikembangkan

43

Apa keuntungan penggunaan prosedur dalam program ini? Yang paling

mencolok adalah ketika hasil perhitungan umur salah, Anda tidak perlu

memeriksa seluruh program, namun cukup bagian yang menghitungnya, yaitu

prosedure HitungUmur.

Pembuatan prosedur dimulai dengan header berupa kata kunci procedure, diikuti nama prosedur, lalu jika memiliki argumen / parameter, tambahkan dengan

daftar parameter dalam tanda kurung, diakhiri dengan titik koma. Nama prosedur

dan argumen harus merupakan pengenal yang valid. Setelah itu, diikuti body dari

prosedur dalam blok begin end;. Body berisi perintah perintah seperti dalam program. Diantara header dan body, Anda dapat mendeklarasikan variabel,

konstanta, atau apapun yang bisa dideklarasikan dalam program (kecuali klausa

uses27). Pemanggilan prosedur dilakukan dengan menuliskan nama prosedur, diikuti

parameter parameter yang diminta (Anda sudah mempelajarinya ketika

menelaah WriteLn (Bab Halo, Dunia!), lihat lagi jika lupa).

Argumen / Parameter

Argumen / parameter merupakan perwakilan dari nilai yang diberikan saat

pemanggilan prosedur. Sebagai contoh, kita dapat memanggil prosedur

HitungUmur seperti di bawah ini:

HitungUmur(25,5,1998);

Ketika prosedur dipanggil, nilai 25 akan dikopi ke Tgl, 5 ke Bln, dan 1998 ke

Thn. Bagaimana dengan contoh di atas? Sama saja, nilai yang terdapat pada

variabel Tanggal dikopi ke Tgl, Bulan ke Bln, dan Tahun ke Thn. Parameter dapat

memiliki nama yang sama dengan variabel yang digunakan sebagai parameternya.

Sebagai contoh, penulisan ulang prosedur HitungUmur seperti di bawah ini valid

dan tidak memerlukan penggantian nama variabel pada program utama. Hal ini

yang disebut dengan aturan ruang lingkup atau scope.

27 Hal ini dikarenakan penggunaan pustaka berlaku secara global dalam program

44

procedure HitungUmur(Tanggal,Bulan: Byte; Tahun: Word); begin WriteLn('Umur Anda sekarang ', YearsBetween( EncodeDateTime(Tahun,Bulan,Tanggal,0,0,0,0), DateOf(Now) ), ' tahun.'); end;

Parameter terbagi dalam beberapa jenis, namun yang paling umum

digunakan hanya 3, yaitu parameter nilai, parameter variabel, dan parameter

konstan. Ketiganya akan dijelaskan pada subbab Penyampaian Parameter.

Prosedur di Dalam Prosedur

Berbeda dengan beberapa bahasa pemrograman lain, Pascal mendukung

deklarasi prosedur di dalam prosedur (nested procedure). Hal ini dapat membantu

jika body dari prosedur terlalu panjang, sehingga akan lebih baik jika dibagi

dalam subprosedur subprosedur. Contohnya dapat dilihat pada program berikut.

1 program Nested; 2 3 procedure Outer(s: String); 4 5 procedure Inner; 6 begin 7 WriteLn(s); 8 end; 9 10 begin 11 Inner; 12 end; 13 14 begin 15 Outer('Hello'); 16 end. 17

Program 8.2 Prosedur di dalam prosedur

Prosedur dalam (disebut child procedure) dapat mengakses parameter

prosedur luar (disebut parent procedure). Sehingga, dalam program ini

pengaksesan s oleh Inner valid walaupun s adalah parameter dari Outer. Selain

45

parameter, seluruh definisi yang ditulis dalam prosedur luar sebelum deklarasi

prosedur dalam dapat diakses oleh prosedur dalam. Misalnya, jika kita membuat

procedure Outer; var a: Byte; procedure Inner; begin a:=5; end; var b: Byte; begin Inner; end;

Maka, Inner dapat mengakses a tapi tidak b.

Catatan

Jika Anda perhatikan baik-baik, maka program sebenarnya adalah nested

procedure juga. Perbedaannya hanya pada penggunaan klausa uses, global directive28, dan deklarasi parameter.

Aturan Ruang Lingkup

Perhatikan program di bawah ini baik-baik. Menurut Anda, bagaimana

keluaran dari program tersebut? Bandingkan dengan hasil sebenarnya. Dalam

program, seringkali kita memerlukan nama variabel yang umum digunakan,

misalnya i, j, atau k untuk variabel index dari loop for. Hal ini mungkin akan membingungkan jika Anda menggunakannya baik pada program utama maupun

prosedur prosedur yang terdapat di dalamnya. Untuk itulah diberlakukan aturan

ruang lingkup, agar tidak terjadi tumpang tindih antara variabel variabel

tersebut.

28 Direktive yang yang berlaku dari awal hingga akhir program. Directive akan dijelaskan pada Bab Kompilasi Kondisional / Preprocessing.

46

1 program Scope; 2 var 3 a: Byte; 4 5 procedure Outer; 6 var 7 a: Byte; 8 9 procedure Inner; 10 var 11 a: Byte; 12 begin 13 a:=3; 14 WriteLn(a); 15 end; 16 17 begin 18 a:=2; 19 WriteLn(a); 20 Inner; 21 WriteLn(a); 22 end; 23 24 begin 25 a:=1; 26 WriteLn(a); 27 Outer; 28 WriteLn(a); 29 end. 30

Program 8.3 Penerapan aturan ruang lingkup

Perhatikan bahwa baik program utama, prosedur luar, maupun prosedur

dalam memiliki variabel bernama a dengan tipe Byte. Ingat aturan bahwa prosedur dalam dapat mengakses variabel prosedur luar (prosedur luar pun dapat

mengakses variabel program utama, karena program utama adalah prosedur luar

bagi prosedur tersebut) asal deklarasinya sebelum deklarasi prosedur dalam. Lalu

bagaimana dengan kasus seperti di atas?

Aturan ruang lingkup menyatakan bahwa ruang lingkup suatu pengenal

(karena hal ini tidak hanya berlaku pada variabel) adalah mulai dari blok ia

dideklarasikan hingga akhir blok tersebut dan blok yang lebih dalam memiliki

prioritas lebih tinggi dari blok luar. Maka, dalam kasus di atas masing-masing

prosedur tidak mengakses variabel milik parent-nya, namun hanya variabel

47

masing-masing. Sehingga perubahan nilai yang terjadi melalui pemberian nilai

hanya berlaku secara lokal (dalam prosedur itu saja).

Aturan ruang lingkup sebenarnya sederhana, namun jika tidak teliti dapat

membuat program Anda tidak berjalan seperti yang diharapkan.

Tugas 4.1

Untuk menguji pemahaman Anda, buatlah prosedur-prosedur berikut:

1. Prosedur untuk mencetak setiap kata dalam suatu kalimat (1 baris 1 kata) (1

argumen bertipe String) 2. Prosedur untuk mencetak setiap digit dari suatu bilangan desimal (1 baris 1

digit), dimulai dari digit terakhir (1 argumen bertipe ordinal)

3. Generalisasikan nomor 1 sehingga dapat memisahkan kata berdasarkan suatu

karakter pembatas!

Penyampaian Parameter

Bagaimana parameter diberikan kepada sebuah prosedur dan apa efeknya

terhadap parameter tersebut baik di dalam prosedur maupun pada ruang lingkup ia

dideklarasikan bergantung pada cara penyampaiannya. Tiga yang paling umum

dan sering digunakan adalah parameter nilai, parameter variabel, dan parameter

konstan.

Parameter nilai (pass by value) menyampaikan parameter dengan cara

mengopi nilai yang akan diberikan ke masing-masing parameter. Dalam prosedur,

parameter ini dapat digunakan maupun diganti-ganti nilainya. Namun, hal ini

tidak akan mempengaruhi nilai aslinya karena yang diganti sebenarnya adalah

kopiannya. Parameter ini tidak memerlukan kata kunci apapun. Program 8.1 dan

8.2 merupakan contoh penggunaan parameter nilai dalam prosedur.

Parameter variabel (pass by reference) menggunakan cara yang relatif sama

dengan parameter nilai, hanya saja yang dikopi bukanlah nilainya, tetapi alamat

dari nilai tersebut. Karena itu, untuk parameter ini kita tidak dapat menggunakan

nilai eksplisit, namun harus dengan variabel sebab nilai eksplisit tidak (selalu)

memiliki alamat dalam memori. Dalam prosedur, penggantian nilai pada

48

parameter mengakibatkan nilai aslinya juga berubah. Karenanya, parameter

variabel biasanya digunakan untuk mengembalikan nilai majemuk (lihat subbab

Fungsi). Untuk menggunakan parameter ini tuliskan kata kunci var sebelum nama parameter pada header prosedur. Contoh penggunaannya dapat dilihat pada

program 8.4.

Parameter konstan mengindikasikan bahwa nilai yang ada pada parameter

tidak boleh diganti-ganti. Biasanya digunakan jika Anda ingin memastikan bahwa

prosedur yang Anda buat tidak mengubah nilai dari parameter. Pada contoh

HitungUmur di atas, nilai parameter Tgl, Bln, atau Thn bisa saja secara tidak

sengaja kita ubah dan mengakibatkan kesalahan dalam perhitungan umur.

1 program PassByRef; 2 3 procedure TambahDua(var x: Byte); 4 begin 5 x:=x+2; 6 end; 7 8 var 9 a: Byte; 10 begin 11 a:=1; 12 WriteLn(a); // 3 13 TambahDua(a); 14 WriteLn(a); // 5 15 end. 16

Program 8.4 Penggunaan parameter variabel

Dengan parameter konstan, hal ini dapat diketahui saat kompilasi sehingga hasil

yang tidak diinginkan dapat dihindari. Parameter ini akan di-pass by value atau di-

pass by reference tergantung ukurannya. Jika < ukuran pointer29 pada arsitektur bersangkutan, maka pass by value yang digunakan. Jika sebaliknya, pass by

reference. Pada dasarnya, hal ini hanya untuk mempercepat eksekusi karena pass

by reference lebih ringan (hanya sebesar ukuran pointer). Bagaimanapun, nilai

29 Tipe data terstruktur yang sangat powerful namun juga berbahaya jika tidak digunakan dengan hati-hati.

49

parameter tersebut tetap tidak boleh diganti-ganti (kecuali dengan trik tertentu).

Untuk menggunakan parameter ini tuliskan kata kunci const sebelum nama parameter pada header prosedur. Untuk contoh, silakan dicoba sendiri.

Catatan

Dalam Modern Pascal, parameter variabel dan parameter konstan dapat tidak

memiliki tipe (untyped). Hal ini tidak akan dibahas karena merupakan topik yang

cukup advanced, dan penggunaannya pun bisa dibilang sangat jarang karena hal

ini mengurangi keamanan program dalam hal pemeriksaan tipe.

Fungsi

Dalam Pascal penggunaan prosedur sebenarnya lebih natural, namun

diperlukannya variabel sebagai parameter variabel terkadang menjengkelkan

(karena kita mungkin membutuhkan nilai aslinya) dan membuat program menjadi

kurang terbaca. Ditambah lagi, pengembalian nilai tunggal (jauh) lebih sering

terjadi dibandingkan nilai majemuk. Untuk memfasilitasi hal tersebut, dibuatlah

fungsi.

1 program Fungsi; 2 3 function HitungDigit(l: LongWord): Byte; 4 begin 5 HitungDigit:=0; 6 while l>0 do begin 7 Inc(HitungDigit); 8 l:=l div 10; 9 end; 10 end; 11 12 begin 13 WriteLn(HitungDigit(256)); // 3 14 WriteLn(HitungDigit(1234567890)); // 10 15 end. 16

Program 8.5 Fungsi penghitung banyak digit suatu desimal

50

Perbedaannya dengan prosedur hanya terletak pada penggunaan kata kunci

function dan adanya deklarasi tipe nilai balikan setelah deklarasi parameter (atau setelah nama fungsi jika tidak memiliki parameter). Untuk mengembalikan nilai,

dalam body-nya nama fungsi digunakan sebagai variabel. Semua hal yang berlaku

pada prosedur juga berlaku pada fungsi.

Tugas 4.2

Buatlah fungsi-fungsi berikut!

1. Fungsi penghitung nilai KPK (2 argumen bertipe ordinal, balikan bertipe

ordinal)

2. Fungsi penghitung nilai FPB (2 argumen bertipe ordinal, balikan bertipe

ordinal)

3. Fungsi penentu apakah suatu bilangan merupakan bilangan prima (1 argumen

bertipe ordinal, balikan bertipe Boolean) 4. Fungsi untuk menghitung nilai akar-akar persamaan kuadrat. Kembalikan

nilai false jika diskriminan negatif, true jika sebaliknya (2 argumen bertipe ordinal, balikan bertipe Boolean)

5. Fungsi untuk mengonversi bilangan desimal ke biner, oktal, dan heksadesimal

(1 argumen bertipe ordinal, balikan bertipe String) Bonus:

1. Modifikasi nomor 1 dan 2 sehingga bisa menghitung untuk 3 bilangan

sekaligus!

2. Generalisasikan nomor 5 sehingga bisa mengembalikan representasi desimal

dalam basis 2 36!

Referensi Maju

Prosedur / fungsi hanya dapat dipanggil setelah dideklarasikan (sama seperti

variabel). Bagaimana jika Anda memiliki prosedur-prosedur yang saling

memanggil satu sama lain? Prosedur yang lebih dahulu dideklarasikan tidak akan

dapat memanggil prosedur lain setelahnya karena belum dideklarasikan. Masalah

51

ayam dan telur30 ini dapat diselesaikan dengan referensi maju (forward

reference). Perhatikan program 8.6 berikut.

1 program FwdRef; 2 3 procedure Later(const i: Byte); forward; 4 5 procedure Sooner(const i: Byte); 6 Begin 7 WriteLn(i); 8 if i>0 then Later(i-2); 9 end; 10 11 procedure Later(const i: Byte); 12 Begin 13 WriteLn(i); 14 if i>0 then Sooner(i+1); 15 end; 16 17 Begin 18 Sooner(5); 19 end. 20

Program 8.6 Referensi maju untuk prosedur-prosedur yang saling rekursif

Cara menggunakan referensi maju adalah dengan mendeklarasikan header

prosedur tersebut diikuti dengan modifier31 forward, seperti program 8.6 di atas.

Catatan

Free Pascal mengharuskan deklarasi header tersebut sama dengan deklarasi

lengkapnya termasuk parameter dan nilai balikan (untuk fungsi). Hal ini

dikarenakan Free Pascal mendukung function overloading32. Beberapa kompilator

lain (misal: Turbo Pascal) mengizinkan penghapusan daftar parameter saat

deklarasi lengkap.

30 Jawab pertanyaan berikut: Mana yang lebih dahulu ada, ayam atau telur? Masalah yang mirip dengan pertanyaan tersebut sering disebut masalah ayam dan telur 31 Modifier dapat mengubah sifat fungsi / prosedur. Mulai dari perjanjian pemanggilan, membuat nama alias, dan lain-lain 32 Deklarasi beberapa fungsi / prosedur dengan nama yang sama namun dengan argumen yang berbeda

52

Ketika Anda mempelajari bab pemrograman modular, maka setiap fungsi /

prosedur yang dideklarasikan pada bagian interface secara implisit akan memiliki modifier forward.

53

Pengulangan 2 : Rekursi

Setiap prosedur / fungsi dapat memanggil fungsi lain, maka dapatkah ia

memanggil dirinya sendiri? Hal inilah yang disebut dengan rekursi. Rekursi biasa

dipakai untuk menyelesaikan masalah yang bisa dipecah-pecah menjadi masalah

yang lebih kecil (disebut recursive case) sampai tidak dapat dipecah lagi (disebut

base case). Rekursi merupakan implementasi dari deduksi dalam matematika.

Contoh rekursi yang paling umum adalah fungsi faktorial seperti pada program

9.1 berikut.

1 program Rekursi; 2 3 function Faktorial(const n: Byte): LongWord; 4 begin 5 if n

54

Pada dasarnya, semua iterasi dapat dibuat versi rekursinya. Perhatikan program

9.2 berikut.

1 program IterRek1; 2 3 var 4 i: Byte; 5 begin 6 for i:=1 to 10 do 7 WriteLn(i); 8 end. 9

Program 9.2a Loop for sederhana

1 program IterRek2; 2 3 procedure Loop(const Awal,Akhir: Byte); 4 begin 5 if Awal

55

Tipe Data Lanjutan

Selain tipe-tipe dasar seperti Integer, Char, dan Boolean, Pascal juga

memiliki tipe data lanjutan, yaitu tipe data yang dapat dibentuk dari satu atau

lebih tipe data dasar atau tipe data lanjutan lainnya. Sebelum mempelajari bab ini,

pastikan Anda sudah cukup menguasai tipe data dasar.

Larik / Array

Larik / Array adalah tipe data yang dapat menampung banyak nilai yang

memiliki tipe dasar yang sama. Larik sering digunakan sebagai tempat

penyimpanan data sementara dalam berbagai proses, misalnya pengurutan dan

pencarian data. Contoh penggunaan larik dapat dilihat pada program 10.1 berikut.

1 program TabelKuadrat; 2 3 type 4 TTabelKuadrat = array [1..100] of Word; 5 6 var 7 TK: TTabelKuadrat; 8 i,n: Byte; 9 begin 10 for i:=Low(TK) to High(TK) do 11 TK[i]:=i*i; // Inisialisasi tabel 12 ReadLn(n); 13 WriteLn('Kuadrat dari ',n,' adalah ',TK[n]); 14 end. 15

Program 10.1 Larik sebagai tabel kuadrat

Sebelum membahas larik-nya, kita berhadapan dengan elemen baru dari

bahasa Pascal, yaitu definisi tipe. Definisi tipe digunakan untuk membuat tipe

baru, baik sebagai alias untuk tipe yang lama (untuk memperjelas program), atau

untuk penulisan tipe data terstruktur seperti contoh di atas. Definisi tipe ditandai

dengan penggunaan kata kunci type, diikuti oleh nama tipe baru, tanda =,

56

definisinya, dan diakhiri dengan ;. Seperti variabel, lebih dari 1 definisi dapat

ditulis dalam blok type yang sama. Keuntungan definisi tipe adalah ketika kita akan mengubah elemen tipe

tersebut (misalnya, jangkauan 1..100 diubah menjadi 0..99), kita hanya perlu

mengubah pada bagian definisi tipe saja, tidak perlu untuk setiap deklarasi

variabel. Pada konstruksi program tertentu, definisi tipe merupakan keharusan.

Maka, lebih baik jika Anda selalu menggunakannya untuk mendefinisikan tipe

data terstruktur.

Sebagai perjanjian, setiap definisi tipe sebaiknya diberi prefiks T. Hal ini

untuk menghindari terjadinya name clash33 dengan variabel / konstanta yang

dideklarasikan oleh unit tertentu.

Catatan

Hati-hati, definisi tipe menggunakan =, bukan :! Karena itulah ia disebut

definisi, bukan deklarasi.

Sekarang, kita akan mempelajari penggunaan array. Bayangkan array

sebagai kumpulan variabel yang sejenis (tipe data sama), yang hanya berbeda

namanya. Variabel TK pada program di atas bisa diasumsikan sebagai 100 buah

variabel TK1, TK2, TK3, ..., TK100. Hanya saja, dapat digunakan dengan lebih

efektif dan efisien, yaitu dengan menggunakan index.

Index diletakkan dalam kurung siku setelah nama variabel, dalam contoh di

atas, misalnya TK[n] menunjukkan index ke n pada variabel TK. Dengan

menggunakan index, kita dapat memanipulasi semua nilai yang terdapat di

dalamnya tanpa perlu menulis satu per satu, yaitu dengan menggunakan bantuan

loop. Index tidak harus berupa nilai langsung, namun dapat berupa ekspresi apa

saja yang mengembalikan nilai yang setipe dengan index tersebut. Pengaksesan

larik di luar index-nya akan mengakibatkan error, baik saat kompilasi maupun

dijalankan, tergantung ekspresinya.

33 Konflik karena pengenal yang sama digunakan lebih dari satu kali

57

Index tidak terbatas pada bilangan saja, semua tipe cacahan (beserta

subjangkauannya) bisa menjadi index dari larik. Contoh: Array ['a'..'z'] of Byte; Merupakan larik dengan index bertipe Char, yang setiap elemennya bertipe Byte.

Latihan:

1. Buatlah program yang menerima input berupa string sebanyak 5 kali, lalu tampilkan dalam bentuk tabel string-string tersebut beserta panjang masing-

masing! Asumsikan panjang maksimum masing-masing string adalah 10.

Contoh keluaran:

string | panjang ----------+--------- Mario | 5 Ray | 3 Mahardhika| 10 Ganteng | 7 Sekali | 6

2. Buatlah program untuk menyelesaikan suatu sistem persamaan linier dengan 2

unknown (x dan y)! Contoh untuk persamaan 2x + 3y = 6 dan x - 2y = 4:

Input: Output:

2 3 6 x = 0

1 -2 4 y = -2

Perhatikan bahwa nilai x / y bisa berupa pecahan. Gunakan tipe data yang

sesuai!

Larik dapat pula dibuat lebih dari 1 dimensi, biasa disebut larik

multidimensi (multidimensional array). Caranya adalah dengan menggunakan

larik lain sebagai tipe elemennya. Larik 2 dimensi umumnya digunakan sebagai

matriks atau tabel koordinat. Dimensi yang lebih tinggi bisa digunakan untuk

perhitungan geometri yang mendalam. Contoh larik multidimensi dapat dilihat

pada program berikut.

58

1 program MatrixTest; 2 3 const 4 n = 3; NumWidth = n-1; 5 6 type 7 TMatrix = array [1..n] of array [1..n] of ShortInt; 8 9 procedure PrintMatrix(const M: TMatrix); 10 var 11 i,j: Byte; 12 begin 13 { Cetak pembatas atas } 14 Write(#218); // Sudut kiri atas 15 for i:=1 to n*(NumWidth+1)+1 do Write(' '); 16 WriteLn(#191); // Sudut kanan atas 17 { Cetak isi matriks } 18 for i:=1 to n do begin 19 Write(#179' '); // Garis tegak lurus 20 for j:=1 to n do Write(M[i,j]:NumWidth,' '); 21 WriteLn(#179); // Garis tegak lurus 22 end; 23 { Cetak pembatas bawah } 24 Write(#192); // Sudut kiri bawah 25 for i:=1 to n*(NumWidth+1)+1 do Write(' '); 26 WriteLn(#217); // Sudut kanan bawah 27 end; 28 29 var 30 M: TMatrix; 31 i,j: Byte; 32 begin 33 for i:=1 to n do 34 for j:=1 to n do 35 M[i][j]:=n*(i-1)+j; 36 PrintMatrix(M); 37 end. 38

Program 10.2 Larik 2 dimensi untuk perhitungan matriks

Terdapat 1 elemen baru lagi, yaitu definisi konstanta. Bagian ini cukup

mudah, pahami saja bahwa pengenal yang digunakan adalah alias dari nilai yang

didefinisikan. Nilai tersebut boleh berupa ekspresi, asalkan ekspresi tersebut dapat

dihitung pada saat kompilasi (tidak mengandung variabel). Keuntungannya

adalah, misalnya dalam program ini, untuk mengubah ukuran matriks, cukup ubah

nilai n maka seluruh nilai n pada program juga akan terubah secara otomatis.

59

Untuk mempermudah penulisan dan memperpendek kode, disediakan jalan

pintas dalam membuat larik multidimensi. Pada contoh di atas, penulisan TMatrix

bisa dipersingkat menjadi: array [1..n,1..n] of ShortInt; begitu juga untuk pengaksesan elemen, (walaupun tidak terlalu signifikan karena

hanya menghemat 1 karakter). M[i][j] bisa dipersingkat menjadi M[i,j]. Programmer Pascal pada umumnya lebih suka menggunakan versi yang

dipersingkat karena lebih mirip dengan definisi tipenya.

Latihan:

Buatlah program untuk menghitung determinan dari matriks 2 dimensi dan 3

dimensi!

Pengurutan dan pencarian data biasa dilakukan dengan menggunakan larik.

Beberapa algoritma akan dipelajari di sini. Untuk pengurutan, kita akan

membahas bubble sort, selection sort, dan quicksort. Sementara untuk pencarian,

akan dibahas linear search dan binary search.

To be continued ...

Enumeration / Pencacahan

Himpunan / Set

Rekaman / Record

Penunjuk / Pointer

Berkas / File

Tipe Data Prosedural