MODUL MATA KULIAH LOGIKA DAN ALGORITMA
STIMIK EL RAHMA JOGJAKARTA 2015
JURUSAN : SISTEM INFORMASI SEMESTER GENAP 2015
Materi :
PROCEDURE DAN FUNCTION
Program yang besar lebih sulit dimengerti dan lebih sulit lagi dalam melakukan pelacakan kesalahan (Jika ada). Oleh karena itu, program sebaiknya dipecah menjadi beberapa sub program yang lebih kecil.
Setiap sub program melakukan komputasi yang spesifik. Sub program yang baik adalah sub program yang independent dari program utama, sehingga programnya dapat dirancang tanpa mempermasalahkan bagaimana sub program tersebut dilakukan, tetapi cukup memikirkan apa yang ia lakukan.
Sub program yang bagus menyembunyikan detil operasi dari bagian program yang tidak perlu tahu tentang sub-program tersebut. Teknik pemecahan program menjadi sejumlah sub program dinamakan teknik pemrograman modular.
Modular artinya penyelesaian seluruh masalah dapat dipecah-pecahkan dengan unsur-unsur langkah penyelesaian spesifik berbentuk modul yang berwujud prosedur (procedure) dan fungsi (function).
Keuntungan Pemrograman Modular
Untuk aktivitas yang harus dilakukan lebih dari satu kali, modularisasi
menghindari penulisan teks program yang sama secara berulangkali. Disini sub-program cukup ditulis sekali saja, lalu sub-program dapat dipanggil dari bagian lain di dalam program. Disini, penggunaan sub-program dapat mengurangi panjang sub-program.
Kemudahan menulis dan menemukan kesalahan (debug) program. Kemudahan menulis akan sangat berguna pada masalah besar yang dikerjakan oleh satu tim pemrogram yang beranggotakan beberapa orang.
Masalah yang akan diprogram dipecah menjadi beberapa masalah
Satu modul bisa berisi dari satu atau lebih sub-program. Seluruh modul diintegrasikan menjadi satu buah program yang lengkap.Program yang modular menjadi lebih mudah untuk dibaca dan dimengerti. Program yang tidak modular sulit dipahami, khususnya kalau program tersebut panjang atau terdiri dari puluhan, ratusan, atau ribuan baris instruksi.
Karena setiap sub-program melakukan aktivitas spesifik, maka apabila terdapat kesalahan di dalam program, kesalahan tersebut cukup dilokalisir di dalam sub-program yang bersangkutan. Kebanyakan program komputer ditulis modular, meskipun program tersebut tidak melibatkan ekseskusi yang berulang dari aktivitas yang sama. Pemecahan program menjadi modul-modul yang lebih kecil umumnya dianggap sebagai praktik pemrograman yang baik dan terstruktur.
Terdapat 2 bentuk sub-program, yaitu prosedur (procedure) dan fungsi (function). Dimana struktur setiap sub-program tersebut pada hakikatnya sama dengan struktur program biasa, yaitu ada bagian judul (header) yang berisi nama modul, bagian deklarasi, dan badan (body) program yang berisi instruksi yang akan dilaksanakan.
Variabel Global dan Variabel Lokal
Variabel global adalah variabel yang dapat dipakai diseluruh program, di program utama atau di dalam procedure atau function.
Variabel lokal hanya dapat dipakai di tempat pendefinisiannya. Jika variabel lokal didefinisikan didalam procedure, maka hanya procedure tersebut yang mengenalnya.
Suatu variabel atau peubah akan dideklarasikan global atau local tergantung kepada penggunaan nama tersebut.
Jika suatu variabel digunakan di seluruh bagian program (termasuk di dalam prosedur), maka variabel tersebut harus dideklarasikan global. Sebaliknya, jika variabel tersebut hanya digunakan di dalam prosedur/function saja, maka nama variabel “sebaiknya” dideklarasikan sebagai variabel lokal saja, meskipun bila dideklarasikan global pun masih tetap benar.
nama tersebut, karena variabel lokal hanya dipakai di dalam lingkup procedure atau function saja.
Procedure/function yang baik adalah yang independen dari program pemanggilnya. Pernyataan ini menyiratkan bahwa procedure/function yang baik tidak menggunakan variabel-varibel global di dalam badan procedur / function-nya. Jika program utama perlu mengkomunikasikan nilai variabel global ke dalam procedure/fucntion, maka ada satu cara untuk melakukannya yaitu dengan menggunakan parameter. Karena parameter dapat mengurangi kebutuhan penggunaan variabel global.
Parameter
Kebanyakan program memerlukan informasi antara procedure ( atau fungsi) dimana ia dipanggil. Penggunaan parameter menawarkan mekanisme pertukaran informasi tersebut. Tiap item data ditransfer antara parameter actual dan parameter formal yang bersesuaian.
Parameter actual adalah parameter yang disertakan pada waktu
pemanggilan, sedangkan parameter formal adalah parameter yang
dideklarasikan didalam bagian header procedure/function itu sendiri. Ketika procedure/function dipanggil, parameter actual menggantikan parameter formal. Tiap-tiap parameter actual berpasangan dengan parameter formal yang bersesuaian.
Berdasarkan maksud penggunaannya, terdapat tiga jenis parameter formal yang disertakan didalam procedure/function, yaitu :
a. Parameter masukan (input) → parameter yang nilainya berlaku sebagai masukan untuk procedure/function.
b. Parameter keluaran (output)→parameter yang menampung keluaran yang dihasilkan oleh procedure.
c. Parameter masukan/keluaran (input/output parameter)→ parameter yang berfungsi sebagai masukan sekaligus keluaran bagi procedure tersebut.
Jika program utama ingin meng-komunikasikan panjang alas dan tinggi segitiga ke prosedur Luas_Segitiga, maka peubah alas dan tinggi harus dideklarasikan sebagai parameter formal dibagian header prosedur :
Procedure Luas_Segitiga( input alas, tinggi :
Parameter keluaran dideklarasikan didalam header prosedur, sebagaimana parameter masukan. Parameter keluaran harus dideklarasikan dengan kata kunci input :
Procedure Luas_Segitiga( input alas, tinggi : real, output luas : real )
Dalam function hanya ada parameter masukan saja.
Bila procedure menghasilkan keluaran yang digunakan oleh program pemanggil, gunakan parameter keluaran untuk menampung keluaran tersebut.
Sebaliknya, bila procedure tidak menghasilkan keluaran, atau kalaupun menghasilkan keluaran dan ternyata keluaran tersebut hanya digunakan di dalam procedure itu saja, gunakan parameter masukan. Bila procedure menerima masukan sekaligus keluaran pada parameter yang sama, gunakan parameter masukan/keluaran.
a. Jumlah parameter actual pada pemanggilan procedure/function harus sama dengan jumlah parameter formal pada deklarasi procedure/function-nya.
b. Tiap parameter actual harus bertipe sama dengan tipe parameter formal yang bersesuaian.
PROCEDURE (PROSEDUR)
Procedure adalah modul program yang mengerjakan tugas/aktivitas yang spesifik dan menghasilkan suatu efek netto. Pada beberapa bahasa pemrograman, procedure dikenal dengan nama subroutine. Atau lebih jelasnya, procedure merupakan sekumpulan instruksi yang dibungkus yang akan dipakai / dipanggil dalam program utama. Ini berarti, instruksi-instruksi didalam procedure baru dapat dilaksanakan hanya bila procedure tersebut diakses.
Struktur Procedure :
Notasi Algoritmik :
Procedure NamaProcedure(deklarasi parameter,jika ada)
{Spesifikasi procedure, berisi penjelasan tentang apa yang dilakukan oleh prosedur ini,
keadaan sebelum prosedur dijalankan dan setelah prosedur dijalankan}
Deklarasi :
{Semua nama yang dipakai dalam prosedur didefinisikan disini dan hanya
berlaku lokal di dalam prosedur}
Algoritma :
{Badan prosedur, berisi kumpulan instruksi}
Keterangan :
Dalam bahasa Pascal, pendefinisian prosedur ditulis bersatu di
dalam program utama, kecuali jika direalisasikan sebagai unit. Prosedur diletakkan dibawah kata var.
Bahasa Pascal memungkinkan prosedur mempunyai parameter masukan, parameter keluaran, dan parameter masukan/keluaran. Parameter formal yang bertipe keluaran atau masukan/keluaran harus diawali dengan kata kunci var, sedangkan untuk parameter formal yang bertipe masukan tidak diawali dengan kata kunci var.
Argumen parameter aktual dilewatkan ke parameter formal
bertipe masukan sebagai “by value”, sedangkan bila parameter formalnya bertipe keluaran atau masukan/keluaran, maka argumen parameter aktual dilewatkan sebagai “By reference”
Contoh procedure : Algoritmik:
Procedure NamaProcedure(deklarasi parameter,jika ada);
{Spesifikasi procedure, berisi penjelasan tentang apa yang dilakukan oleh prosedur ini,
keadaan sebelum prosedur dijalankan dan setelah prosedur dijalankan}
(* Deklarasi *) var
{Semua nama yang dipakai dalam prosedur didefinisikan disini dan hanya
berlaku lokal di dalam prosedur}
(*Algoritma*) begin
Procedure Luas_Segitiga {Procedure tanpa parameter)
Deklarasi : {Variabel Lokal} alas,tinggi,luas: real
Algoritma :
write('Masukan alas segitiga: ') read(alas)
write('Masukan tinggi segitiga: ') read(tinggi)
luas (alas*tinggi)/2 write('luas segitiga: ',luas)
Procedure Tukar1 ( input A,B :integer) {Procedure dengan 2 parameter input)
Deklarasi : Temp:integer
Algoritma : Temp A A B B Temp
Procedure Maksimum ( input A,B:integer; output Maks:integer)
{Procedure dengan 2 parameter input dan 1 parameter output)
Algoritma : if A>B then maks A else
Procedure Tukar2 ( input /output A,B :integer) {Procedure dengan 2 parameter input/output)
Deklarasi : Temp:integer
Algoritma : Temp A A B B Temp
Program Contoh_Prosedur
Deklarasi : x,y,maksi:integer
Procedure Luas_Segitiga
Procedure Tukar1 ( input A,B :integer)
Procedure Maksimum ( input A,B:integer; output Maks:integer)
Procedure Tukar2 ( input /output A,B :integer)
Algoritma : {Program Utama} Luas_Segitiga
write('Masukan Angka ke-1: ') read(X)
write('Masukan Angka ke-2: ') read(Y)
Maksimum(X,Y,maksi)
write('Angka ke-1: ',x,' ','Angka ke-2: ',Y,' ','Nilai Maksimum: ',maksi)
Tukar1(X,Y)
Write('Angka ke-1 sekarang nilainya: ',X) Write('Angka ke-2 sekarang nilainya: ',Y) Tukar2(X,Y)
Write('Angka ke-1 sekarang nilainya: ',X) Write('Angka ke-2 sekarang nilainya: ',Y)
Program Contoh_prosedur; var
X,Y,maksi:integer;
procedure luas_segitiga; var
alas,tinggi,luas:real; begin
write('Luas segitiga:',luas); end;
procedure tukar1 (a,b:integer); var
procedure maksimum(a,b:integer;var
maks:integer);
write ('Masukan angka ke-1:');
Function adalah modul program yang memberikan/mengembalikan (return) sebuah nilai dan tipe tertentu. Sebagaimana halnya dengan procedure, function diakses dengan memanggil namanya. Selain itu, fungsi juga dapat mengandung daftar parameter formal. Parameter pada fungsi sama seperti didalam prosedur, tetapi hanya ada parameter masukan saja jika ada. Function hanya dapat mengembalikan nilai bertipe sederhana. Karena itu, tipe hasil dari fungsi haruslah dari tipe sederhana.
Struktur Function :
Notasi Algoritmik :
Function NamaFunction(deklarasi parameter,jika ada):tipe
{Spesifikasi function, berisi penjelasan tentang apa yang dilakukan dan yang dikembalikan oleh function}
Deklarasi :
{Semua nama yang dipakai dalam function didefinisikan disini dan hanya
berlaku lokal di dalam function }
Algoritma :
{Badan function, berisi kumpulan instruksi-instruksi untuk menghasilkan nilai yang
Notasi Pascal :
Keterangan :
Dalam bahasa Pascal, function hanya dapat mengembalikan nilai
bertipe sederhana (integer, real, boolean, char, dan string). Karena itu, tipe hasil dari fungsi haruslah dari tipe sederhana.
Apabila function tidak memiliki daftar parameter formal, maka tanda ‘( )’ tidak ditulis.
Function dideklarasikan sekaligus didefinisikan di dalam blok
program utama pemanggil (sesudah kata kunci var).
function NamaFunction(deklarasi parameter,jika ada):tipe
{Spesifikasi function , berisi penjelasan tentang apa yang dilakukan dan yang dikembalikan oleh function}
(* Deklarasi *) var
{Semua nama yang dipakai dalam function didefinisikan disini dan hanya
berlaku lokal di dalam function }
(*Algoritma*) begin
{Badan function, berisi kumpulan instruksi-instruksi untuk menghasilkan nilai yang
akan dikembalikan oleh function}
NamaFunction:= ekspresi; {pengembalian nilai yang dihasilkan fungsi}
Cara memanggil function:
Function diakses dengan cara memanggil namanya dari program pemanggil, diikuti dengan daftar parameter actual (bila ada). Karena fungsi menghasilkan nilai, maka nilai tersebut ditampung dalam sebuah peubah yang bertipe sama dengan tipe fungsi.
peubah namafunction(daftar parameter actual)
atau nilai yang dikembalikan oleh function dapat langsung dimanipulasi seperti contoh-contoh berikut:
write (Namafunction(daftar parameter actual))
if (Namafunction(daftar parameter actual)) < 0 then ……..
z2* (Namafunction(daftar parameter actual))-x+y
Contoh function :
Algoritmik :
Function
NilaiRata(a,b,c:integer):real
Deklarasi : NR:real
Algoritma :
Program Contoh_fungsi
Deklarasi :
Nilai1,Nilai2,Nilai3:integer RataRata:real
Function NilaiRata(a,b,c:integer):real
Algoritma :
write('Nilai 1 : ') read(Nilai1) write('Nilai 2 : ') read(Nilai2) write('Nilai 3 : ') read(Nilai3)
RataRataNilaiRata(Nilai1,Nilai 2,Nilai3)
write('Nilai rata-rata adalah ', RataRata)
Perhatikan bagian deklarasi function: function NilaiRata(a,b,c:integer):real
Function di atas mempunyai 3 parameter nilai,yaitu a,b,c. Ketiga parameter tersebut bertipe integer.Hasil dari function NilaiRata bertipe real. Di dalam function harus ada pernyataan yang memberi nilai pada function, pada contoh diatas adalah: NilaiRataNR.
Perhatikan cata pemanggilan function didalam program utama: NilaiAkhirNilaiRata(Nilai1,Nilai2,Nilai3)
Karena hasil dari function NilaiRata bertipe real,maka NilaiAkhir juga harus bertipe real.
Pascal:
Program Contoh_fungsi; var
Nilai1,Nilai2,Nilai3:integer; RataRata : real;
function NilaiRata (a,b,c : integer):real; var
begin
RataRata:=NilaiRata(Nilai1,Nilai2,Nilai3); write('Nilai rata-rata adalah ', RataRata);
end.
KESIMPULAN
Fungsi digunakan apabila modul program mengembalikan sebuah
nilai.
Prosedur digunakan bila modul menghasilkan effek netto dari (satu atau) sekumpulan aksi.
Fungsi dapat dikonversi sebagai prosedur dengan cara menyatakan
nilai yang dikembalikan (return value) oleh fungsi tersebut sebagai parameter keluaran pada prosedur.
Prosedur yang mempunyai satu buah parameter keluaran dapat
ditulis sebagai fungsi dengan cara menyatakan parameter keluaran sebagai nilai yang dikembalikan oleh fungsi.
Latihan
- Buatlah program untuk menghitung berbagai luas dengan menggunakan procedure .
- Buat procedure yang menghasilkan nilai rata-rata sekumpulan data
bilangan bulat yang dibaca secara berulang-ulang dari keyboard (akhir pembacaan adalah 9999). Prosedur ini memiliki parameter keluaran, yaitu nilai rata-rata yang dihasilkan.
