Diposting oleh Hanif | | Posted On Jumat, 02 Maret 2012 at 19.27
Maeri Perkuliahan
PEMROGRAMAN MODULAR
Catatan ini akan membahas mengenai “ Pemrograman Modular “.Di mana
pemrograman modular ini merupakan salah satu kemudahan yang diberikan oleh
Turbo Pascal terhadap programmer, karena di sini programmer dapat membagi
program yang sedang dibuatnya ke dalam modul-modul program tertentu. Sehingga
dapat menghindari penulisan teks program yang sama berkali-kali dan dapat juga
memudahkan dalam melakukan pelacakan kesalahan dalam program yang sedang
dibuatnya.
Ada 2 jenis
pemograman modular yang dibahas dalam praktikum ini, yaitu :
1.
PROCEDURE (Prosedur)
2.
FUNCTION (Fungsi)
PROCEDURE
Deklarasi :
Procedure NamaProcedure (DaftarParameter)
;
{Deklarasi}
Begin
.............
.............
End
;
Suatu procedure bukan
merupakan program yang berdiri sendiri sehingga tidak dapat dieksekusi secara langsung.
Untuk itu suatu procedure memerlukan sebuah akses pada program utama / modul
lain yang befungsi sebagai pemanggil. Sedangkan cara pemanggilannya adalah
dengan : menuliskan nama procedurenya
berikut parameternya (jika ada).
Terdapat 2 jenis Procedure dan Fuction, diantaranya :
1. Procedure Pustaka, yaitu procedure yang sudah
disediakan oleh kompilernya sehingga programmer tidak perlu membuatnya sendiri,
contoh procedure pustaka adalah antara lain CLRSCR, GOTOXY(..,..), dll.
2. Procedure user defined, yaitu procedure yang
dibuat oleh user/programmer dalam rangka agar programnya menjadi terstruktur.
(Pada
catatan ini akan lebih dibahas tentang procedure user defined)
Hal-hal yang berhubungan dengan procedure :
Ada beberapa hal yang berhubungan dengan penulisan sebuah procedure
program yaitu :
1.
Variabel Global dan variabel
Variabel Global adalah variabel yang
dapat dikenali diseluruh bagian program biasanya variabel ini merupakan
variabel yang dideklarasikan pada deklarasi program utama.
Variabel Lokal adalah variabel yang
dikenal pada lingkup yang lebih sempit dari pada variabel global. Biasanya
dideklarasikan dalam procedure ataupun function.
Catatan :
Untuk deklarasi dalam procedure
ataupun function yang memiliki nama variable yang sama dengan variable global,
maka nilai yang akan diload adalah dalam scope (ruang lingkupnya)
masing-masing.
Contoh :
Program tesvariabel;
Var a,b : integer;
Procedure vardalam();
Var a : integer;
Begin
a := 10;
b := 15;
writeln(“a dalam = “,a);
End;
Begin
a := 100;
b := 200;
writeln(“a = “,a);
writeln(“b = “,b);
vardalam();
writeln(“a = “,a);
writeln(“b = “,b);
end.
Hasil run program :
a = 100 // variable a
yang diload merupakan variable global yang telah
dideklarasikan
sebelumnya dengan nilai 100
b = 200 // variable
b yang diload merupakan variable global yang telah
dideklarasikan
sebelumnya dengan nilai 200
a dalam = 10 // variable
a dalam yang diload merupakan variable lokal yang
dideklarasikan di dalam procedure vardalam().
Procedure ini hanya memberi nilai pada variable a di dalam,sehingga tidak
merubah nilai variable a luar.
a = 100 // variable
a yang diload tetapmemiliki nilai seperti awal karena
tidak
terpengaruh oleh procedure vardalam()
b = 15 // procedure
vardalam() telah mengubah nilai variable b global
karena procedure vardalam() tidak memiliki variable b, maka ia akan
menggunakan variable global, dan kemudian mengubahnya dengan 15.
2.
Parameter
Ada 2 parameter yang berlaku dalam sebuah procedure, yaitu :
a.
Parameter Formal
Yaitu parameter yang dideklarasikan mengikuti pendeklarasian prosedur.
b.
ParameterAktual
Yaitu parameter yang dituliskan mengikuti pemanggilan procedure
Aturan
antara parameter formal dan parameter aktual :
1)
Banyaknya parameter aktual
harus sama dengan banyaknya parameter formal
2)
Tiap-tiap parameter aktual
harus bertipe sama dengan parameter formal yang bersesuaian
3)
Tiap-tiap parameter aktual
harus diekspresikan yang sesuai dengan parameter formal
Pengiriman
parameter :
a.
Pengiriman parameter secara
nilai (by Value)
-
Tiap-tiap parameter dalam procedure utama akan beisi
nilai yang dikirim oleh parameter aktual dan bersifat lokal diprocedure
-
Pengiriman nilai parameter
secara by value merupakan pengiriman searah, artinya hanya dari parameter
aktual ke parameter formal
-
Perubahan parameter formal
tifak mempengaruhi terhadap nilai parameter actual
Contoh :
Procedure Hitung(A,B,C : integer) ;
Begin
B: = A;
C: = A + B ;
Writeln(A,B,C) ;
End;
Var X,Y,Z : integer
;
Begin
Readln(X) ; Readln(Y) ;
Readln(Z) ;
Hitung(X,Y,Z) ; Writeln(X,Y,Z) ;
Readln ;
End.
Ket :
Misalkan dimasukkan nilai dari
X=5, Y=7 dan Z=15 maka nilai ini akan dikirim ke parameter formal pada
procedure yaitu A,B,C sehingga nilai
awal A=5, B=7 dan Z=15. Setelah melalui proses maka hasil outputnya adalah
bahwa nilai X=5 , Y=7 dan Z=15. Sebab
apapun yang diproses pada procedure tidak akan mempengaruhi nilai dari
parameter aktual X,Y,Z.
b.
Pengiriman parameter secara
acuan (by Reference)
-
Merupakan pengiriman dua arah
yaitu dari parameter aktual ke parameter formal dan dari parameter formal ke
parameter aktual sebagai hasil output dari procedure
-
Perubahan nilai pada parameter
formal mempengaruhi pada parameter aktual
-
Dicirikan dengan pengunaan
deklarasi VAR , pada parameter procedurenya
Contoh :
Procedure Hitung(Var A,B,C : integer) ;
Begin
B: = A;
C: = A + B ;
Writeln(A,B,C) ;
End;
Var X,Y,Z : integer ;
Begin
Readln(X) ; Readln(X) ; Readln(X) ;
Hitung(X,Y,Z) ;
Writeln(X,Y,Z) ;
Readln ;
End.
Ket :
Misalkan dimasukkan nilai dari
X=5, Y=8 dan Z=15 maka nilai ini akan dikirim ke parameter formal pada
procedure yaitu A,B,C sehingga nilai
awal A=5, B=8 dan C=15. Setelah melalui proses maka hasil outputnya adalah
bahwa nilai X=A=5 , Y=B=A=5 dan Z=C=10.
Sebab apapun yang diproses pada procedure akan mempengaruhi nilai dari
parameter aktual X,Y,Z.
Contoh program
yang menggunakan procedure :
Program
KOMBINASI;
uses crt;
var f1,f2,f3:longint;
n,r,delta:integer;
c: real;
Procedure facto( n:integer;
var f:longint);
var i:integer;
begin
f:=1;
for i:=1 to n do
f:= f * i;
end;
{======================PROGRAMUTAMA==================}
Begin
clrscr;
gotoxy(12,3);
write('Kita
akan menghitung nilai kombinasi dari suatu angka');
gotoxy(19,4);
writeln('Yang mempunyai
rumus : rCn = n!/(r!(n-r)!)'); gotoxy(20,5);
writeln('Nilai r harus
lebih kecil/sama dengan n');
writeln;gotoxy(28,6);
write('Masukkan nilai n
:',' ');readln(n);
writeln;gotoxy(28,8);
write('Masukkan nilai r
:',' ');readln(r);
facto(n,f1);
facto(r,f2);
delta:=(n-r);
facto(delta,f3);
c:= f1/(f2*f3);gotoxy(30,10);
write('Hasilnya :',' ',c:2:0);
readln;
end.
Hasil Run
Program :
Kita akan menghitung nilai kombinasi dari suatu angka
Yang mempunyai rumus : rCn = n!/(r!(n-r)!)
Nilai r harus lebih kecil/sama dengan n
Masukkan nilai n : 6
Masukkan nilai r : 2
Hasilnya : 15
FUNCTION
Deklarasi :
Function NamaFungsi(NamaParameter) :
TipeData ;
{Deklarasi}
Begin
...........
...........
End
;
Struktur dari fungsi ini hampir sama dengan procedur hanya saja
function harus dideklarasikan beserta tipe datanya dan fungsi ini adalah
mengembalikan nilai sehingga Tipe data
dalam sebuah function menunjukkan tipe dari data akhir dari deklarasi
sebuah fungsi.
Suatu fungsi
dapat dipanggil dengan menggunakan beberapa cara, misalkan :
Nama Fungsinya
adalah Rata, maka ia akan dapat dipanggil dengan menggunakan
Rata2 : = Rata(vector,Ukuran) ;
X : = Y + Rata(vector,Ukuran) ;
Write(‘Nilai rata-ratanya = ‘, rata(vector,ukuran));
Perbedaan prinsip antara procedure dengan function :
1.
Pada function nilai yang
dikirim balik terdapat nama fungsinya (Karena nama fungsi digunakan untuk
menampung nama fungsi yang terakhir)
2.
Function dapat langsung
ditampikan hasilnya. Misal : writeln( Hitung(X,Y)) ;
Catatan :
Untuk keterangan yang lain yang meliputi macam variabel, parameter,
aturan antar parameter dan cara pengiriman parameter sama dengan yang ada pada
procedure, sehingga tidak perlu dituliskan lagi.
Keuntungan menggunakan deklarasi procedure atau
function:
a.
Program mudah dipahami
Dengan membuat procedure-procedure yang akan
digunakan,misalnya procedure hitung, maka bentuk program utamanya kurang lebih
sebagai berikut :
Begin
Readln(X) ; Readln(Y) ;
Readln(Z) ;
Hitung(X,Y,Z) ; Writeln(X,Y,Z) ;
Readln ;
End.
Terlihat lebih mudah untuk di pahami
maksud dari program utama di atas.
b.
Program mudah diperbaiki jika
terjadi kesalahan (error)
Jika terdapat error, baik sintax
error, running error ataupun output error, maka akan mudah ditelusuri dimana
letak errornya apakah pada program utama, pada procedure hitung atau pada waktu
menentukan frekuensi.
c.
Program mudah dimodifikasi atau
dikembangkan
Seandainya akan dilakukan modifikasi
atau pengembangan program, akan lebih mudah, misalkan akan dimodifikasi bagian
tampilan input atau output, atau akan diganti algoritma untuk mengurutkan
datanya dengan algoritma yang lebih cepat, semua dapat dilakukan dengan lebih
mudah
d.
Program akan menjadi lebih
ringkas
Jika pada program utama terdapat suatu alur procedure
yangakan digunakan berulang kali, maka programmer tidak perlu mengetikkan isi
dari procedure itu berulang kali, programmer hanya perlu memanggil nama dari
Procedure atau Function tersebut.
Contoh:
Begin
Readln(X) ; Readln(Y) ;
Readln(Z) ;
Hitung(X,Y) ;
Hitung(Y,Z);
Writeln(X,Y,Z) ;
Readln ;
End.
Pada listing program di atas, programmer hanya perlu memanggil
Procedure Hitung dua kali, tidak perlu mengetikkan isi dari Procedure Hitung
dua kali.
Contoh Program yang menggunakan fungsi :
Program faktorial;
Uses crt;
Var i,N,Hsl:integer;
Function Fakto(N:integer):integer;
Var Fak: integer;
Begin
Fak:= 1;
for i:=1 to N do
Fak := Fak * i;
Fakto:= Fak;
end;
Begin
clrscr;
write('Faktorial berapa
yang anda ingin hitung : ');
readln(N);
writeln('Hasil perhitungan
: ',Fakto(N));
readln;
end.
Hasil Run Program :
Faktorial berapa yang anda ingin
hitung : 5
Hasil perhitungan : 120
Dalam turbo Pascal telah dikenal ada beberapa tipe data yang
kemudian dapat digolongkan menjadi 2
kelompok besar tipe data yaitu
tipe data standard dan tipe data
terstruktur. Pada laporan ini akan dibahas mengenai tipe-tipe data terstruktur
yang meliputi tipe data array, tipe data record dan tipe data set.
REKURSI
Salah satu keistimewaan yang dimiliki oleh Turbo Pascal adalah bahwa
pascal dapat melakukan suatu proses yang dinamakan sebagai proses Rekursi, yaitu proses untuk memanggil
dirinya sendiri. Dalam procedure dan function proses ini bisa berarti proses
berulang yang tidak diketahui kapan akan berakhirnya. Contoh paling sederhana
dari proses rekursi adalah Proses mencari faktorial dari suatu.
Faktorial N
= N!
= N (N-1) (N-2)……………..3.2.1
N! = N (N-1)! ,untuk N>0
N! = N (N-1) (N-2)!
Jika ditulis
dalam program menjadi :
Faktorial(0) = 1 ;
Faktorial(N) = N (N-1)!
Ini merupakan
sebuah hubungan rekurens yang berarti nilai suatu fungsi dengan argument
tertentu dapat dihitung dengan menggunakan fungsi yang sama hanya saja dengan
argument yang lebih kecil.
Contoh :
Program
faktorial;
Uses crt ;
Var i , N , Hsl : integer
Function
Fakto(N:integer):integer ;
Var Fak: integer ;
Begin
if (N=0) or (N=1) then
Fakto:= 1
else
Fakto:= N*Fakto(N-1) ;
end;
Begin
clrscr;
write('Faktorial berapa
yang anda ingin hitung : ') ;
readln(N) ;
writeln('Hasil perhitungan
: ',Fakto(N)) ;
readln ;
end .
Hasil Run Program :
Faktorial berapa yang anda ingin
hitung : 5
Hasil perhitungan : 120
Dari program
diatas maka notasi Fakto(N-1) yang digunakan untuk memanggil program sebelumnya
dinamakan sebagai Pemanggil atau rekursi.
Posting Komentar