PENGANTAR PEMROGRAMAN MODULAR

Untuk mencapai suatu tujuan besar , maka tujuan tersebut harus dibagi bagi menjadi
tujuan kecil sampai tujuan kecil itu merupukan tujuan yang dapat dicapai berdasarkan
kondisi dan potensi yang dimiliki saat itu (Al-Khuwarizmi).
Ucapan Al-Khuwarizmi diatas sangat mengena dalam kegiatan memprogram.
Program yang besar lebih sulit dibaca (dimengerti) dan lebih sulit lagi dalam pelacakan
kesalahan atau proses debugging (jika ada). Oleh karena itu , program sebaiknya dibagi
menjadi beberapa upa-progra(subprogram/subroutine) yang lebih kecil dan terstruktur
melakukan fungsi atau komputasi masing masing secara spesifik.
Upa-program yang baik adalh upa-program yang independepen dari program utama
sehingga programnya dapat dirancang tanpa mempertimbangkan konteks dimana ia
digunakan. Dengan kata lain, pemogram tidak perlu mempermasalahkan bagaimana
upaprogram tersebut dilakukan, tetapi cukup memikirkan apa yang ia lakukan.
Teknik pemecahan program menjadi sub-program dinamakan teknik pemrograman
modular (modular programming). Beberapa bahasa pemrograman lain menamakan
pemrograman modular dengan sebutan sub-rutin (subroutine), module , prosedur , atau
fungsi.
CONTOH PEMROGRAMAN MODULAR
/* Program mengecek sebuah palindrom */
#include <stdio.h>
#include <string.h>
main()
{
char a[100],b[100];
printf(Ketik Sesuatu : \n);
gets(a);
strcpy(b,a);
strrev(b);
if(strcmp(a,b)==0)
{
printf(Yang anda inputkan adalah palindrom \n);
}
else
{
}

printf(Yang anda inputkan Bukan palindrome \n);

return 0;
}
Algoritma 1.1 Program pengecekan palindrom

Program di atas dapat kita pecah menjadi dua buah upa-program yang spesifik, yaitu
upa-program untuk membaca character ( a dan b ) , upa-program untuk proses mengcopy
string dan membalikan hasil copy dari string (a ke b), dan upa-program untuk mengecek
kondisi string dan menampilkan hasil pengecekan string yang merupakan palindrom , seperti
di bawah ini :
void Baca (char *a[100])
/* Membaca nilai a */
{
printf(Ketik sesuatu : \n);
gets(a);
}
void Proses(char *a[100], char *b[100])
/* Proses mengcopy dan membalik */
{
strcpy(*a,*b); /* mengcopy char a ke b */
strrev(*b); /* string reverse : membalik char b */
}
void Cek_Tampil(char *a[100], char *b[100])
/* Mengecek string dan Menampilkan */
{
if(strcmp(*a,*b)==0) /* Kondisi membandingkan a dan b
{
printf(Yang anda inputkan adalah palindrom \n);
}
else
{
printf(Yang anda inputkan Bukan palindrome \n);
}
return 0;
}
Algoritma 1.2 Program pengecekan palindrom.

Masing masing upa-program mempunyai struktur yang serupa dengan program

utama, dengan pemecahan menjadi sejumlah program , program terlihat menjadi lebih
sederhana. Program utama hanya perlu mendklarasikan upa-program tersebut sebelum
mereka digunakan(program utama dinyatakan sebagai bagian yang diarsir Algoritma 1.2).
Upa-program di eksekusi dengan memanggil namanya. Ketika sebuah upa-program dipanggil
pelaksanaan program sekarang berpindah ke upa-program tersebut , selanjutnya seluruh
intruksi di dalam upa-program dilaksanakan setelah seluruh intruksi didalam upa-program
selesai dikerjakan, dilaksanakan program kembali ke program pemanggil (dalam hal ini
program lama ). Untuk melaksanakan intruksi berikutnya.

/* Program pengecekan palindrom */

#include <stdio.h>
void Baca(char *a[100])
void Proses(char *a[100], char *b[100])
void Cek_Tampil(char *a[100], char *b[100])
main() /* Program Utama */
{
/* Deklarasi */
char a[100], b[100];
Baca(a);
Proses(&a,&b);
Cek_Tampil(&a,&b);
}
void Baca (char *a[100])
/* Membaca nilai a */
{
}

printf(Ketik sesuatu : \n);

gets(a);

void Proses(char *a[100], char *b[100])

/* Proses mengcopy dan membalik */
{
}

strcpy(*a,*b); /* mengcopy char a ke b */

strrev(*b); /* string reverse : membalik char b */

void Cek_Tampil(char *a[100], char *b[100])

/* Mengecek string dan Menampilkan */

if(strcmp(*a,*b)==0) /* Kondisi membandingkan a dan b

{
printf(Yang anda inputkan adalah palindrom \n);
}
else
{
printf(Yang anda inputkan Bukan palindrome \n);
}
return 0;
}

Keuntungan Pemrograman Modular

Modularisasi program memiliki dua keuntungan. Pertama, untuk aktuvitas yang harus
dilakukan lebih dari satu , modularisasi menghundari dari penulisan teks program yang sama
secara berulang kali. Di sini , upa-program cukup ditulis sekali saja, lalu upa-program dapat
di panggil dari bagian lain di dalam program . Di sini , penggunaan upa-program dapat
mengurangi panjang program. Sebagai contoh, tinjau program dalam bahasa C di dalam
Algoritma 1.3 . Hanya bagian algoritma yang sama dan ditulis berulang-ulang yang
ditampilkan disini( bagian yang di beri tanda x ). Bagian algoritma lain cukup dinyatakan
dengan ....

/* Program xyz */
#include <stdio.h>
main()
{
/* Deklarasi */
int A,B,C,D,temp.
/* Algoritma */
...
...
/* Pertukaran nilai a dan b */
temp=A;
A=B;
B=temp;
...
...
...
if(C>D)
{

|
| x
|

/* Pertukaran nilai c dan d */

temp=C;
C=D;
C=temp;

|
| x
|

}
...
...
}

Algoritma 1.3 Contoh program yang beberapa kali berisi bagian pertukaran.
Di dalam Algoritma 1.3 diatas ada bagian program yang ditulis berulang kali
keduanya melakukan aktivitas yang sama. Yaitu pertukaran nilai antara dua buah peubah kita
dapat menulis bagian yang ditulis berulangkali tersebut ke dalam satu buah upa-program
yang diberi nama tukar. Upa-program yang bernama tukar diakses dengan memanggilnya dari
dalam program utama Algoritma 1.4.
/* Program xyz */
#include <stdio.h>
void Tukar(int *A, int *B); /*deklarasi subroutine yang digunakan*/
main()
{
/* Deklarasi */
int A,B,C,D, temp;
/* Algoritma */
...
...
/* Pertukaran nilai A dan B */
Tukar(&A, &B);
...
...
...
if(C>D)
{
/* Pertukaran nilai C dan D */
Tukar(&C, &D);
}
...
...
}
void Tukar(int *A, int *B)
/* Mempertukarkan nilai A dan B */

{
/* Deklarasi */
int temp;
(peubah bantu)
/* Algoritma */
temp=A;
A=B;
B=temp;
}

Algoritma 1.4 Contoh program dengan menyatakan bagian pertukaran menjadi subroutine
Tukar.