1 / 214

PEMROGRAMAN MODULAR

PEMROGRAMAN MODULAR. adalah suatu teknik pemrograman di mana program yang biasanya cukup besar dibagi-bagi menjadi beberapa bagian program yang lebih kecil . Dalam beberapa bahasa pemrograman disebut : sub-rutin, modul, prosedur, atau fungsi. STRUKTUR POHON. ILUSTRASI. DEKLARASI

reilly
Download Presentation

PEMROGRAMAN MODULAR

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. PEMROGRAMAN MODULAR • adalah suatu teknik pemrograman di mana program yang biasanya cukup besar dibagi-bagi menjadi beberapa bagian program yang lebih kecil . • Dalam beberapa bahasa pemrograman disebut : sub-rutin, modul, prosedur, atau fungsi.

  2. STRUKTUR POHON

  3. ILUSTRASI DEKLARASI A, B, Temp : integer ALGORITMA { baca nilai A dan B} read(A) read(B) {proses pertukaran} temp  A A  B B  temp { tulis nilai A dan B setelah pertukaran } output(A) output(B)

  4. Dipecah subprogram DEKLARASI A, B : integer Baca(A,B:Integer) ALGORITMA: read(A) read(B) Tukar(A, B:integer) DEKLARASI temp : integer {peubah bantu} ALGORITMA temp  A A  B B  temp Tulis(A,B : integer) ALGORITMA output(A) output(B) ALGORITMA Baca(A,B) Tukar(A,B) Tulis(A,B)

  5. KEUNTUNGAN Pemrogram Modular 1. Program lebih pendek2. Mudah menulis (banyak programer) 3. Mudah dibaca dan dimengerti(bandingkan dg nonmodular dg banyak instruksi) 4. Mudah didokumentasi5. Mengurangi kesalahan dan mudah mencari kesalahan(debug) program 6. Kesalahan yang terjadi bersifat “lokal”

  6. Dua bentuk pemrogram modular : PROSEDUR dan FUNGSI • Struktur setiap subprogram tersebut pada hakekatnya sama , yaitu : • Nama modul (subprogram) • Bagian deklarasi • Algoritma (intruksi yg akan dilaksanakan) • Perbedaan penggunaannya dalam bahasa pemrograman Pascal : • Prosedur merupakan modul(subprogram) yg melakukan aktifitas tertentu tanpa adanya pengembalian nilai • Fungsi terdapat pengembalian nilai

  7. PROSEDUR • Dalam bahasa pemrograman • Prosedur adalah modul program yang mengerjakan tugas/aktifitas yg spesifik dan menghasilkan suatu efek netto(membandingkan keadaan awal dan keadaan akhir dari suatu aktifitas prosedur) • Setiap prosedur perlu mendefinisikan keadaan awal sebelum rangkaian instruksi di dalam prosedur dilaksanakan, dan keadaan akhir yg diharapkan setelah instruksi di dalam prosedur dilaksanakan

  8. STRUKTUR PROSEDUR • JUDUL (header)  nama prosedur dan deklarasi parameter(kalau ada) • DEKLARASI  mengumumkan nama-nama dan tipe data • ALGORITMA  badan prosedur (instruksi) *sama dengan struktur ALGORITMA

  9. Nama Prosedur • Nama yang unik • Sebaiknya diawali dengan kata kerja karena prosedur berisi suatu aktifitas • Misalnya: HitungLuas, Tukar, CariMaks, Tulis, dll.

  10. Parameter • Adalah nama-nama peubah (variabel) yang dikdeklarasikan pada bagian header (judul) prosedur dan titik dimana dia dipanggil. • Penggunaan parameter menawarkan mekanisme pertukaran informasi (antara yg memanggil (program/algoritma utama) dg prosedur itu sendiri)

  11. Parameter dibedakan menjadi dua : • Parameter aktual (argumen) : • Parameter yg disertakan pada waktu pemanggilan prosedur (parameter yg ada pada program/algoritma utama). • Parameter formal : • Parameter yg dideklarasikan di dalam bagian header prosedur itu sendiri. • Ketika prosedur dipanggil, parameter aktual menggantikan parameter formal. • Tiap-tiap parameter aktual berpasangan dengan parameter formal yg bersesuain (berkorespondasi satu satu)

  12. Notasi algoritma untuk PROSEDUR Procedure NamaProsedur(deklarasi parameter, jika ada) {spesifikasi prosedur, berisi penjelasan tentang apa yg dilakukan oleh prosedur ini. K.awal : keadaan sebelum prosedur dilaksanakan. K. akhir : keadaan setelah prosedur dilaksanakan} DEKLARASI {semua nama yg dipakai di dalam prosedur dan hanya berlaku lokal di dalam prosedur ini} ALGORITMA {badan prosedur, berisi urutan instruksi}

  13. Pendeklarasian Parameter dalam prosedur bukanlah keharusan Contoh : Procedure HitungLuasSegitiga {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak} DEKLARASI Alas, tinggi, luas : real ALGORITMA Read(alas, tinggi) Luas  (alas * tingg) / 2 Write(luas)

  14. Pemanggilan Prosedur • Prosedur bukan program yg beridiri sendiri • Prosedur tidak dapat dieksekusi secara langsung. • Instruksi-instruksi di dalam prosedur dapat dilaksanakan bila prosedur itu diakses. • Prosedur diakses dg cara memanggil namanya dari program pemanggil (misalnya dari program utama atau modul program lainnya) • Jika prosedur tanpa parameter, maka pemanggilannya cukup dg nama prosedurnya saja, contoh :HitungLuasSegitiga

  15. Notasi Algoritma : PROGRAM Segitiga {menghitung luas segitiga} DEKLARASI Procedure HitungLuasSegitiga {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak} DEKLARASI Alas, tinggi, luas : real ALGORITMA Read(alas, tinggi) Luas  (alas * tinggi) / 2 Write(luas) ALGORITMA HitungLuasSegitiga

  16. KUIS • BUATLAH NOTASI ALGORITMA UNTUK MELAKUKAN PEMANGGILAN PROSEDUR LUASSEGITIGA SEBANYAK 3 X

  17. Nama Global dan Nama Lokal • Nama Lokal : Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam prosedur (termasuk parameter, jika ada). (hanya dikenal/digunakan dalam lingkup (scope) prosedur tersebut • Nama Global : Nama-nama (Konstanta, peubah(variabel), tipe, dll) yang dideklarasikan di dalam program utama. (dapat dikenal/digunakan dibagian manapun dalam program (progam utama maupun prosedur).

  18. _______________________________________________________________Nama Peubah (variabel) I, N, alas, tinggi  variabel GLOBALNama Peubah (variabel) luas  variabel LOKAl PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : sembarang} {K.akhir : luas segitiga tercetak} DEKLARASI luas : real ALGORITMA Luas  (alas * tinggi) / 2 Write(luas) ALGORITMA read(N) { tentukan banyaknya segitiga } for I  1 to N do read(alas, tinggi HitungLuasSegitiga endfor

  19. Menggunakan variabel Global atau variabel Lokal • Bila suatu peubah (variabel) digunakan di seluruh bagian program (baik program utama maupun prosedur), maka deklarasikanlah peubah tsb secara Global. • Bila suatu peubah (variabel) hanya digunakan di dalam prosedur, maka deklarasikanlah peubah tsb secara Lokal. • Gunakan peubah global sedikit mungkin • Penggunaan variabel lokal membuat program lebih elegan • Penggunaan variabel lokal dapat meminimumkan usaha pencarian kesalahan yg disebabkan oleh nama-nama tsb.

  20. Parameter • Prosedur yg baik adalah prosedur yg independen dari program utama/ program yg memanggilnya. • Prosedur yg baik tidak menggunakan peubah-peubah global di dalam prosedur. • Jika program utama perlu mengomunikasikan nilai peubah Global ke dalam prosedur, maka gunakanlah PARAMETER.

  21. Parameter - next • Penggunaan parameter adalah mekanisme pertukaran informasi antara prosedur dengan yang memaggilnya (program utama maupun subprogram lainnya). • Prosedur dengan parameternya (Parameter Formal) dapat diakses dg cara memanggil namanya dari program yg memanggilnya yg disertai dg parameter dari program yg memanggil tsb (Parameter Aktual). Contoh: NamaProsedur(parameter aktual) • Tiap parameter aktual berpasangan dg paramater formal yg bersesuaian

  22. Parameter - next • Ketika prosedur dipanggil, parameter aktual berkoresponden satu-satu dengan parameter formal (parameter yg dideklarasikan pada bagian header prosedur)

  23. Aturan korespondensi satu satu • Jumlah parameter aktual harus sama dengan jumlah parameter formal. • Tiap parameter aktual harus bertipe sama dengan tipe parameter formal yg sesuai. • Tiap parameter aktual harus diekspresikan dalam cara yg taat azas dg parameter formal yg bersesuaian, bergantung pada jenis parameter formal.

  24. Jenis parameter formal yg disertakan di dalam prosedur : • Parameter Masukan (input parameter) : Parameter yg nilainya berlaku sebagai masukan untuk prosedur. • Parameter Keluaran (Output parameter): Parameter menampung keluaran yg dihasilkan oleh prosedur. • Parameter masukan/keluaran (input/output parameter) : Parameter yg berfungsi sebagai masukan sekaligus keluaran bagi prosedur tsb.

  25. Parameter masukan • Nilai parameter aktual diisikan ke dalam parameter formal yg sesuai. • Perubahan nilai parameter di dalam badan prosedur tidak mengubah nilai parameter aktual. • Nama parameter aktual boleh berbeda dg nama parameter formal yg sesuai

  26. Contoh : paramater masukan Procedure HitungLuasSegitiga(input alas, tinggi : real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya} {K.akhir : luas segitiga tercetak} DEKLARASI luas : real ALGORITMA Luas  (alas * tinggi) / 2 Write(luas)

  27. Program utama yg memanggil nama prosedur:harus mendeklarasikan nama prosedur dan memanggilnya dg parameter aktual yg sesuai PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I, N : integer alas, tinggi : real Procedure HitungLuasSegitiga(input alas, tinggi : real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak} DEKLARASI luas : real ALGORITMA Luas  (alas * tinggi) / 2 Write(luas) ALGORITMA read(N) { tentukan banyaknya segitiga } for I  1 to N do read(alas, tinggi HitungLuasSegitiga(alas,tinggi) endfor

  28. nama parameter aktual tidak harus sama dengan nama parameter formal : yg dipentingkan adalah nilainya PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I, N : integer a, t : real Procedure HitungLuasSegitiga(input alas, tinggi : real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak} DEKLARASI luas : real ALGORITMA Luas  (alas * tinggi) / 2 Write(luas) ALGORITMA read(N) { tentukan banyaknya segitiga } for I  1 to N do read(a, t) HitungLuasSegitiga(a,t) endfor

  29. Parameter aktual boleh berupa ekspresi atau konstanta Contoh : • HitungLuasSegitiga(a*0.2, t*0.1) • HitungLuasSegitiga(12, 6)

  30. Parameter keluaran • Parameter keluaran dideklarasikan di dalam header prosedur, sebagaimana parameter masukan • Parameter keluaran dideklarasikan dengan keyword OUTPUT. • Ketika prosedur yg mengandung parameter keluaran dipanggil, maka nama parameter aktual menggantikan (substitute) nama parameter formal yg bersesuaian.

  31. Contoh : parameter keluaran-next PROGRAM Segitiga {menghitung luas N buah segitiga} DEKLARASI I, N : integer a, t, L : real Procedure HitungLuasSegitiga(input alas, tinggi : real, output luas:real) {menghitung luas segitiga dengan rumus : L = (alas x tinggi)/2} {K.awal : alas dan tinggi sudah terdefinisi nilainya } {K.akhir : luas segitiga tercetak} ALGORITMA Luas  (alas * tinggi) / 2 ALGORITMA read(N) { tentukan banyaknya segitiga } for I  1 to N do read(a, t) HitungLuasSegitiga(a, t, L) Write(L) endfor

  32. Parameter masukan/keluaran • Prosedur harus dapat mengakomodasi baik masukan dari dan keluaran ke blok program pemanggil • Maka gunakan parameter masukan/ keluaran • Bila parameter aktual diubah nilainya di dalam badan prosedur, maka sesudah pemanggilan prosedur nilai parameter aktual di titik pemanggilan juga berubah • Parameter masukan/keluaran dideklarasikan di dalam header prosedur dengan keyword INPUT/OUTPUT • Parameter aktual harus berupa peubah, tidak boleh berupa ekspresi atau konstanta

  33. Contoh : parameter masukan/keluaran PROGRAM Cetak0Sampai10 { mencetak nilai dari 0 sampai 10 } DEKLARASI x : integer procedure Inc(input/output x : integer) {menaikan nilai x sebesar 1} {K.Awal : x sudah terdefinisi nilainya} {K.Akhir : nilai x bertambah 1} DEKLARASI ALGORITMA x  x + 1 ALGORITMA X  0 repeat write(x) inc(x) until x > 10

  34. PROGRAM xyz DEKLARASI a, b : integer Procedure tambah(input x,y:integer) Deklarasi Algoritma x  x + 4 Y  y +4 write(‘nilai x dan y di akhir prosedur tambah:’) Write(‘ x=‘, x) Write(‘ y=‘, y) ALGORITMA a  15 B  10 Write(‘nilai a dan b sebelum panggil prosedur tambah:’) Write(‘ a=‘, a) Write(‘ b=‘, b) Tambah(a,b) Write(‘nilai a dan b sesudah panggil prosedur tambah:’) Write(‘ a=‘, a) Write(‘ b=‘, b) PROGRAM xyz DEKLARASI a, b : integer Procedure tambah(input/output x,y:integer) Deklarasi Algoritma x  x + 4 Y  y +4 write(‘nilai x dan y di akhir prosedur tambah:’) Write(‘ x=‘, x) Write(‘ y=‘, y) ALGORITMA a  15 B  10 Write(‘nilai a dan b sebelum panggil prosedur tambah:’) Write(‘ a=‘, a) Write(‘ b=‘, b) Tambah(a,b) Write(‘nilai a dan b sesudah panggil prosedur tambah:’) Write(‘ a=‘, a) Write(‘ b=‘, b) Parameter masukan - parameter masukan/keluaran

  35. Program dg prosedur atau tanpa prosedur • Dianjurkan menulis program yg modular • Program yg dipecah menjadi beberapa prosedur menunjukkan teknik pemrograman yg baik dan terstruktur

  36. Prosedur dg parameter atautanpa parameter • Dianjurkan menulis prosedur dg parameter • Parameter dapat mengurangi kebutuhan penggunaan peubah (variabel) global

  37. Parameter masukan atauparameter keluaran • Bila prosedur menghasilkan keluaran yg digunakan oleh program pemanggil, gunakan parameter keluaran untuk menampung keluaran tsb. • Bila prosedur tidak menghasilkan keluaran, atau kalaupun menghasilkan keluaran tapi keluaran tsb hanya digunakan di dalam prosedur itu saja, maka gunakan parameter masukan. • Bila prosedur menerima masukan sekaligus keluaran pada parameter yg sama, gunakan parameter masukan/keluaran.

  38. Analisa kasus :menentukan jam berikutnya setelah ditambah satu detik • Tambah detik dengan 1, jika jumlah detik <60, tetapi jika jumlah detik = 60 maka set detik kembali menjadi nol(0) dan tambahkan 1 ke menit. • pertambahan menit dengan 1,jika jumlah menit <60, tetapi jika jumlah menit = 60, maka set menit kembali menjadi 0(nol) dan tambahkan 1 ke jam. • Pertambahan jam dengan 1, jika jumlah jam <24, tetapi jika jumlah jam = 24, maka set jam kmbali menjadi 0(nol). Contoh : 14:27:31 +1detik  14:27:(31+1)=14:27:32 15:36:59 +1detik  5:36:(59+1)=15:(36+1):00=15:37:00 10:59:59 +1deti  10:59+(59+1)= 10:(59+1):00 =(10+1):00:00=11:00:00 23:59:59 +1detik  00:00:00

  39. Notasi Algoritma: menentukan jam berikutnya Program jamberikutnya Deklarasi Type jam : record <hh:integer {0..23} mm:integer {0..59} ss : integer {0..59} J :jam ALGORITMA Read(j.hh, j.mm, j.ss) {baca jam} if J.ss +1 < 60 then J.ss  j.ssm +1 else J.ss  0 if J.mm + 1 < 60 then J.mm  J.mm + 1 else J.mm  0 If J.hh + 1 < 24 then J.hh  J.hh + 1 else j.hh  0 endif endif endif Write(J.hh, J.mm, J.ss) {jam yang baru}

  40. Notasi Algoritma : mencetak perjalan waktu terus menerus dg prosedur paramater masukan/keluaran Program JamHidup {membuat jam “hidup” yg selalu bertambah 1 detik terus menerus sampai jam 00:00:00. Masukan jam dibaca daripiranti masukan (keyboard). Setiap pertambahan 1 detik, jam yg baru ditampilkan sebagai keluaran} Deklarasi Type jam : record <hh:integer {0..23} mm:integer {0..59} ss : integer {0..59} J :jam Procedure JamBerikutnya(input/output J : Jam) {Menaikkan jam J dengan satu detik } ALGORITMA Read(J.hh, J.mm, J.ss) {baca jam awal} Repeat write(J.hh, J.mm, J.ss) {cetak jam sekarang} JamBerikutnya(J) Until (J.hh = 0) and (J.mm =0) and (J.ss = 0) write(J.hh, J.mm, J.ss) {cetak jam 00:00:00}

  41. FUNGSI • Sub Program yg mempunyai tujuan/tugas spesifik • Fungsi dan prosedur adalah merupakan sub program yang ekivalen • Dalam beberapa masalah penggunaan salah satunya adalah hal yg lebih tepat.

  42. FUNGSI-next • Adalah sub program yg memberikan/mengembalikan (return) sebuah nilai dari tipe tertentu (tipe dasar atau tipe bentukan) • Fungsi di dalam program bersesuain dengan definisi fungsi di dalam matematika Contoh : a.f(x) = 2X2 + 5X – 8 b. h(x,y) = 3x – y +xy Dimana: f dan h adalah nama fungsi, sedangkan x dan y adalah parameter fungsi yg bersangkutan. Nilai yg diberikan oleh fungsi bergantung pada masukan parameter Misal : x=2, maka f(2) = 2*22 + 5*2 = 10 x=1, y=2, maka h(1,2) = 3*1 – 2+1*2=3 Nilai 10 dan 3 adalah nilai yang diberikan (return) oleh masing fungsi f dan fungsi h.

  43. FUNGSI - next • Parameter pada fungsi disebut juga dengan parameter formal • Parameter pada fungsi selalu merupakan sebagai parameter masukan yg digunakan oleh fungsi tsb untuk menghasilkan nilai. • Fungsi tidak mempunyai parameter keluaran atau parameter masukan/ keluaran

  44. FUNGSI - next • Struktur fungsi sama dengan Struktur prosedur (Header(judul), deklarasi, algoritma(badan fungsi)) • Fungsi diakses dengan memanggil nama fungsi tsb.dari program yg memanggilnya. (sama dengan prosedur).

  45. Struktur fungsi Function NamaFungsi(input deklarasi parameter, jika ada)  tipe ( tipe nilai yg diberikan oleh fungsi) {spesifikasi fungsi, menjelaskan apa yang dilakukan dan yang dikembalikan oleh fungsi} DEKLARASI {semua yg dipakai di dalam fungsi dan hanya berlaku di dalam fungsi didefinisikan di sini} ALGORITMA {badan fungsi, berisi instruksi-instruksi untuk menghasilkan nilai yg akan dikembalikan oleh fungsi} return ekspresi { pengembalian nilai yg dihasilkan fungsi } • Catatan : parameter formal selalu berjenis parameter masukan, sehingga parameter formal selalu diawal dengan keyword INPUT • Ekspresi : dapat berupa konstanta, peubah(variabel) atau sebuah rumus

  46. Struktur fungsi • Fungsi untuk menghasilkan nilai f(x)=2x2+5x-8, x€ R Function f(input x : real)  real {mengembalikan nilai f(x) = 2x2+5x-8, x€ R Deklarasi { tidak ada } Algoritma return 2*x*x + 5*x – 8 ______________________________________________ Catatan : f adalah nama fungsi dengan tipe real x adalah paramater formal dengan tipe real 2*x*x + 5*x – 8 : nilai yg dihasilkan oleh fungsi Return : mengembalikan hasil dari ekspresi 2*x*x + 5*x – 8

  47. Kuis • Buatlah contoh fungsi untuk meghitung nilai dengan dua parameter formal dengan tipe bilangan bulat

  48. Fungsii untuk menentukan bilangan genap atau ganjil Function Genap(input n : integer)  boolean { true jika n adalah bilangan genap, atau false jika tidak genap } Deklarasi { tidak ada } Algoritma : return ( n mod 2 = 0 ) { ekspresi BOOLEAN }

  49. Function NamaHari(input har : integer)  string { mengembalikan nama hari berdasarkan nomor har} DEKLARASI nama : string Algoritma: case har 1: nama  ‘Senin’ 2: nama  ‘Selasa’ 3: nama  ‘Rabu’ 4: nama  ‘Kamis’ 5: nama  ‘Jum’at’ 6: nama  ‘Sabtu’ 7: nama  ‘Minggu’ endcase return nama Function NamaHari(input har : integer)  string { mengembalikan nama hari berdasarkan nomor har} DEKLARASI { tidak ada } Algoritma: case har 1: return  ‘Senin’ 2: return  ‘Selasa’ 3: return  ‘Rabu’ 4: return  ‘Kamis’ 5: return  ‘Jum’at’ 6: return  ‘Sabtu’ 7: return  ‘Minggu’ endcase Fungsi nama hari menggunakan peubah tanpa peubah

  50. Fungsi untuk memeriksa kebenaran sandi Function valid(input p : string)  boolean { true jika password p benar, atau false jika salah } Deklarasi const password = ‘abc123’ { sandi-lewat yg benar } Algoritma: return (p=password)

More Related