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 modelar yang dibahas
dalam praktikum ini, yaitu :
1.
PROCEDURE (Prosedur)
2.
FUNCTION (Fungsi)
PROCEDURE
Deklarasi :
Procedure NamaProcedure(DaftarParameter)
;
{Deklarasi}
Begin
.............
.............
End ;
Pemanggilan Procedure :
Suatu procedure bukan merupakan program
yang berdiri sendiri sehingga tidak dapat dielsekusi 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 umum.
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 dideklarsikan mengikuti pendeklarasian program utama
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 prosecure 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) ; 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) ; 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
Program akan menjadi lebih ringkas
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.
