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 ;

Pemanggilan Procedure :
      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.
0 komentar

Comments:

There are 0 komentar for

Posting Komentar

Langganan: Posting Komentar (Atom)