FUNGSIALGORITMA DAN DASAR PEMROGRAMAN

KONSEP DASAR FUNGSI

Program komputer yang dibuat untuk menjawab permasalahan umumnya berukuran sangat besar, karena itu perlu dibuat potongan-potongan program yang lebih kecil (biasa disebut modul) yang lebih mudah untuk ditangani dibanding dengan program yang terdiri dari banyak baris.

Modul program ini disebut fungsi (function).

KONSEP DASAR FUNGSI

Pemrograman C ditulis dengan mengkombinasikan fungsi baru yang ditulis oleh pemrogram (disebut programmer-defined function) dengan fungsi yang telah tersedia di dalam pustakanya (disebut standard library).

Fungsi merupakan blok dari kode yang dirancang untuk melakukan tugas khusus.

KONSEP DASAR FUNGSI

Tujuan pembuatan fungsi:

1. Program menjadi lebih terstruktur dengan memecah program menjadi beberapa program yang lebih kecil, yang masing-masing mempunyai tugas tertentu.

2. Mengurangi duplikasi kode atau penulisan kode yang sama yang ditulis secara berulang-ulang.

KONSEP DASAR FUNGSI

Supaya dapat digunakan, fungsi harus dapat dipanggil dari bagian program yang membutuhkannya. Karena itu fungsi harus diberi nama dan nama ini harus didefinisikan dan dideklarasikan terlebih dahulu.

Pemanggilan fungsi bertujuan untuk mengerjakan suatu tugas tertentu yang dapat berupa tugas input/output, tugas penyeleksian, atau tugas perhitungan.

KONSEP DASAR FUNGSI

Bagian program yang menggunakan fungsi dapat berkomunikasi dengan fungsinya lewat pengiriman parameter-parameter yang dilakukan melalui argumen-argumen fungsi.

MENDEFINISIKAN FUNGSI Fungsi terdiri dari dua buah komponen

utama, yaitu definisi fungsi dan tubuh fungsi.

Definisi fungsi berisi tipe dari fungsi, nama fungsi, dan argumen-argumennya jika digunakan.

Tubuh fungsi berisi statemen-statemen yang akan melakukan tugas yang diberikan kepada fungsi tersebut, yang ditulis di dalam tanda kurung kurawal buka dan tutup.

MENDEFINISIKAN FUNGSI Bentuk umum fungsi, yaitu:

MENDEFINISIKAN FUNGSI Definisi fungsi ditulis sebelum tubuh

fungsi tanpa diakhiri dengan titik koma. Tipe di definisi fungsi menunjukkan tipe

dari fungsi, dimana tipe dari fungsi ini tergantung dari tipe data hasil balik yang akan diberikan oleh fungsi.Jika hasil balik dari fungsi misalnya berupa nilai pecahan, maka tipe fungsi dapat dibuat float atau double atau long double.

MENDEFINISIKAN FUNGSI Jika fungsi tidak memberikan hasil balik,

maka tipenya adalah void. Tipe dari fungsi ini dapat tidak ditulis jika tipenya adalah int atau char. Jadi, jika suatu fungsi didefinisikan tanpa menggunakan tipenya, maka akan dianggap bertipe int.

Nama dari fungsi merupakan nama yang dibentuk sendiri oleh pembuat program.

MENDEFINISIKAN FUNGSI Sebuah fungsi dapat memiliki satu atau

lebih argumen yang ditulis dengan dipisahkan oleh koma atau suatu fungsi dapat tidak mempunyai argumen sama sekali. Jika argumen tidak digunakan, kurung buka dan kurung tutup setelah nama dari fungsi tetap harus dituliskan.

Tipe data void dapat dituliskan sebagai pengganti argumen untuk fungsi yang tidak menggunakan argumen.

MENDEFINISIKAN FUNGSI Argumen yang berada di definisi fungsi

ini disebut dengan argumen formal atau parameter formal. Parameter-parameter formal ini dimaksudkan sebagai alat komunikasi untuk data yang dikirimkan dari bagian program yang menggunakan fungsi ke fungsi bersangkutan.

MENDEFINISIKAN FUNGSI Parameter-parameter formal dapat

dituliskan dengan dua cara, yaitu cara baru dan cara lama.

Cara baru dilakukan dengan menuliskan parameter-parameter formal yang diawali dengan tipe datanya. Contohnya:

int Fungsi_Ku(float A, int B, char C) Contoh yang salah:

int Fungsi_Ku(float A, B, char C)

MENDEFINISIKAN FUNGSI Cara lama untuk menuliskan parameter formal adalah

dengan memecahnya menjadi dua bagian. Pertama, semua parameter formal ditulis tanpa tipe datanya. Kedua, parameter-parameter formal ini dideklarasikan terpisah dengan tipe datanya setelah definisi dari fungsi. Contoh:

int Fungsi_Ku(A, B, C)

float A;

int B;

char C;

{

/*tubuh fungsi*/

}

/*tidak diakhiri titik koma*//*diakhiri titik koma*//*diakhiri titik koma*//*diakhiri titik koma*/

MENDEFINISIKAN FUNGSI Standar ANSI lebih menganjurkan

penggunaan cara baru. Penulisan parameter-parameter formal

dengan cara lama digunakan pada awal bahasa C diciptakan dan masih banyak yang menggunakannya sampai saat ini untuk menjaga kompatibilitas dengan kompiler C yang menggunakan cara lama. Kompiler-kompiler C yang baru umumnya mendukung dua cara penulisan ini.

MENDEFINISIKAN FUNGSI Berikut ini beberapa contoh penulisan

definisi fungsi yang benar:

char Ke_Besar(char C)

void Tampil_N(int N)

void Hapus_Layar()

void Hapus_Layar(void)

double Maksimum(double X, double Y)

PARAMETER FORMAL & PARAMETER AKTUAL

Parameter formal adalah variabel yang ada pada daftar parameter dalam definisi fungsi.

Parameter aktual adalah parameter yang dapat berupa variabel atau konstanta maupun ungkapan yang dipakai dalam pemanggilan fungsi.

DEKLARASI FUNGSI

Suatu fungsi yang memberikan hasil balik selain tipe int perlu dideklarasikan sebelum digunakan, karena jika suatu fungsi tidak dideklarasikan akan dianggap fungsi tersebut memberikan nilai balik berupa tipe int.

Untuk alasan dokumentasi program yang baik, sebaiknya semua fungsi yang digunakan dideklarasikan terlebih dahulu termasuk yang bertipe int.

DEKLARASI FUNGSI

Beberapa kompiler C dapat diatur untuk selalu mendeteksi semua deklarasi fungsi-fungsi yang digunakan termasuk yang bertipe int.

Deklarasi fungsi ditulis sebelum fungsi tersebut digunakan.

DEKLARASI FUNGSI

Bentuk umum deklarasi fungsi:

tipe nama-fungsi(argumen); Tipe adalah tipe dari fungsi yang akan

digunakan dan harus sama dengan tipe fungsi yang didefinisikan

/* ------------------------------------------------------------------------ Nama Program: ADP_fungsi_1_deklarasi_fungsi.cpp Mendeklarasikan Fungsi ------------------------------------------------------------------------ */

#include <stdio.h>#include <stdlib.h>double Absolut(double X); //deklarasi fungsi

main(){

float Nilai;

printf("Contoh Program Mendeklarasikan Fungsi\n"); printf("__________________________________\n"); printf("\n");

Nilai = -123.45; printf("%7.2f nilai mutlaknya adalah %7.2f\n", Nilai, Absolut(Nilai)); printf("\n");

system("pause");}

//fungsi untuk memutlakkan nilai negatipdouble Absolut(double X) //definisi fungsi{

if(X<0) X=-X; return(X);}

/* ------------------------------------------------------------------------ Nama Program: ADP_fungsi_1_deklarasi_fungsi.cpp Mendeklarasikan Fungsi ------------------------------------------------------------------------ */

#include <stdio.h>#include <stdlib.h>//fungsi untuk memutlakkan nilai negatip//dimana fungsi dideklarasikan terlebih dahuludouble Absolut(double X) //definisi fungsi{

if(X<0) X=-X; return(X);}

main(){

float Nilai;

printf("Contoh Program Mendeklarasikan Fungsi\n"); printf("__________________________________\n"); printf("\n");

Nilai = -123.45; printf("%7.2f nilai mutlaknya adalah %7.2f\n", Nilai, Absolut(Nilai)); printf("\n");

system("pause");}

PROTOTYPE FUNGSI

Prototype fungsi adalah mendeklarasikan fungsi dengan menyebutkan argumen fungsinya.

Pada contoh program ADP_fungsi_1_deklarasi_fungsi.cpp, prototype fungsi terdapat pada bagian deklarasi fungsi dimana fungsi double Absolut menyebutkan argumen fungsi (double X).

HASIL BALIK FUNGSI Suatu fungsi dibuat untuk maksud

menyelesaikan tugas tertentu. Suatu fungsi dapat hanya melakukan

suatu tugas saja tanpa memberikan suatu hasil balik atau melakukan suatu tugas dan kemudian memberikan suatu hasil balik.

Fungsi yang hanya melakukan suatu tugas saja tanpa memberikan hasil balik misalnya adalah fungsi untuk menampilkan hasil di layar.

/* -------------------------------------------------------------------------- Nama Program: ADP_fungsi_2_hasil_balik_fungsi.cpp Hasil Balik Fungsi --------------------------------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Tampil_S_N(char *String, int N); //prototype fungsi

main(){

printf("Contoh Program Hasil Balik Fungsi\n"); printf("_____________________________\n"); printf("\n");

Tampil_S_N("Bahasa C\n",3); printf("\n");

system("pause");}

//fungsi menampilkan n kali nilai stringvoid Tampil_S_N(char *String, int N) //definisi fungsi{

int I; for(I=1;I<=N;I++) printf(String);}

HASIL BALIK FUNGSI Fungsi Tampil_S_N() pada contoh di slide

sebelumnya tidak memberikan hasil balik. Fungsi yang tidak memberikan hasil balik adalah fungsi yang mempunyai tipe hasil void.

Jika suatu fungsi memberikan hasil balik, makanilai hasil balik yang diberikan oleh fungsi dapat dilakukan oleh statemen return yang diikuti oleh nilai hasil baliknya yang ditulis dalam tanda kurung. Statemen return saja tanpa diikuti oleh nilai baliknya akan mengembalikan proses dari fungsi kebagian program yang memanggilnya tanpa memberikan nilai hasil baliknya.

/* -------------------------------------------------------------------------- Nama Program: ADP_fungsi_2a_hasil_balik_fungsi.cpp Hasil Balik Fungsi --------------------------------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Tampil_S_N(char *String, int N); //prototype fungsi

main(){

printf("Contoh Program Hasil Balik Fungsi\n"); printf("_____________________________\n"); printf("\n");

Tampil_S_N("Bahasa C\n",3); printf("\n");

system("pause");}

//fungsi menampilkan n kali nilai stringvoid Tampil_S_N(char *String, int N) //definisi fungsi{

int I; for(I=1;I<=N;I++) printf(String);

return;}

HASIL BALIK FUNGSI Program berikut ini dimaksudkan untuk

menghitung N Faktorial (N!). Nilai N! adalah sebesar 1 x 2 x ... x N dengan N adalah nilai positif. Jika N bernilai negatif atau nol,maka fungsi faktorial() akan memberikan hasil balik nilai 0. Nilai F adalah hasil balik yang akan diberikan oleh fungsi untuk nilai N positif. Variabel F ini pertama kali harus diberikan nilai awal 1. Jika nilai F mempunyai nilai awal 0, maka hasilnya akan selalu nol, karena bilangan apapun dikalikan dengan 0 hasilnya 0.

/* -------------------------------------------------- Nama Program: ADP_fungsi_2b_hasil_balik_fungsi.cpp Hasil Balik Fungsi -------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>long int Faktorial(int N); //prototype fungsi

main(){ int N; long int Fak;

printf("Contoh Program Hasil Balik Fungsi\n"); printf("_________________________________\n"); printf("\n");

printf("Jumlah Faktorial: ");scanf("%d",&N); Fak = Faktorial(N); printf("%d faktorial = %ld\n",N,Fak); printf("\n");

system("pause");}

//fungsi menghitung N faktoriallong int Faktorial(int N) //definisi fungsi{

int I; long int F=1; if(N<=0) return(0); for(I=2;I<=N;I++) F *=I; return(F);}

HASIL BALIK FUNGSI

Program di atas memberikan nilai hasil balik dengan tipe long int. Tipe nilai hasil balik adalah tipe dari fungsinya, sehingga fungsi Faktorial() ini juga harus bertipe long int.

Hubungan antara bagian program yang memanggil fungsi, parameter aktual, parameter formal, dan hasil balik dari fungsi dapat digambarkan seperti pada slide berikutnya.

HASIL BALIK FUNGSI

Hasil dari fungsi Faktorial() ini,yaitu nilai dari F akan dtierima oleh variabel Fak di bagian program yang memanggil fungsi.

VARIABEL-VARIABEL FUNGSI Variabel-variabel yang digunakan untuk

operasi fungsi mempunyai ruang lingkup tertentu, yaitu apakah hanya berlaku di blok statemen saja, di dalam suatu fungsi saja ataukah di semua bagian program.

Terdapat tiga macam variabel, yaitu variabel lokal, global, atau statis.

VARIABEL LOKAL

Variabel Lokal adalah variabel yang nama dan nilainya hanya dikenal di suatu blok statemen tertentu saja atau di dalam suatu fungsi.

Variabel bersifat lokal jika dideklarasikan di dalam blok bersangkutan.

Variabel lokal akan dihapus dari memori jika proses sudah meninggalkan blok statemen dimana variabel lokal terletak.

/* ---------------------------------------------- Nama Program: ADP_fungsi_3_variabel_fungsi.cpp Variabel Lokal Fungsi ---------------------------------------------- */

#include <stdio.h>#include <stdlib.h>float Tambah(float A, float B); //prototype fungsi

main(){ float Hasil;

printf("Contoh Program Variabel Lokal Fungsi\n"); printf("____________________________________\n"); printf("\n");

Hasil = Tambah(2,3); printf("%f\n", Hasil); //Hasil variabel lokal fungsi utama printf("\n");

system("pause");}

//fungsi menampilkan menghitung penambahanfloat Tambah(float A, float B) //definisi fungsi{

float C; //C variabel lokal fungsi Tambah C = A + B; return(C);}

VARIABEL LOKAL

Variabel C pada contoh program di atas merupakan variabel lokal di fungsi Tambah(). Variabel C ini tidak dikenal di fungsi main() (fungsi utama), sehingga variabel ini tidak dapat digunakan di fungsi utama. Sebaliknya variabel Hasil merupakan variabel yang sifatnya lokal di fungsi utama dan tidak dikenal di fungsi Tambah().

VARIABEL GLOBAL

Varibel Global adalah variabel yang dikenal di semua bagian-bagian tertentu dari program. Variabel-variabel global dapat dibuat dengan cara mendeklarasikan di luar suatu blok statemen atau di luar fungsi-fungsi yang menggunakannya.

/* ---------------------------------------------- Nama Program: ADP_fungsi_3_variabel_fungsi.cpp Variabel Global Fungsi ---------------------------------------------- */

#include <stdio.h>#include <stdlib.h>float Tambah(float A, float B); //prototype fungsi

float C; //C variabel globalmain(){ printf("Contoh Program Variabel Global Fungsi\n"); printf("_____________________________________\n"); printf("\n");

Tambah(2,3); printf("%f\n",C); printf("\n");

system("pause");}

//fungsi menghitung penambahanfloat Tambah(float A, float B) //definisi fungsi{

C = A + B; return(C);}

VARIABEL GLOBAL

Variabel C dideklarasikan di luar fungsi utama dan fungsi Tambah(),sehingga bersifat global (dikenal dan dianggap sama) di kedua fungsi tersebut. Karena bersifat global, maka perubahan nilai variabel C di salah satu fungsi tersebut berarti juga merubah nilai variabel C di fungsi yang lainnya.

VARIABEL STATIK Variabel statik bersifat tetap, yaitu tidak

dihapus variabel dan nilainya selama proses program.

Berbeda dengan variabel lokal, yaitu variabelnya akan dihapus setelah proses keluar dari blok yang mendeklarasikannya, maka variabel statik akan tetap ada dan nilainya akan tetap dipertahankan walaupun proses telah keluar dari bloknya.

Variabel statik dibuat dengan dideklarasikan menggunakan pengubah dari (modifier) static.

/* ---------------------------------------------- Nama Program: ADP_fungsi_5_variabel_fungsi.cpp Variabel Statik Fungsi ---------------------------------------------- */#include <stdio.h>#include <stdlib.h>long int X(long int N); //prototype fungsi

main(){ int I, N; long int Fak;

printf("Contoh Program Variabel Statik Fungsi\n"); printf("________________________________\n"); printf("\n");

printf("Berapa Jumlah Faktorial: ");scanf("%d",&N); printf("\n");

//menghitung N faktorial if(N<=0) Fak=0; else for(I=1;I<=N;I++) Fak=X(I); printf("%d faktorial = %ld\n", N, Fak);

system("pause");}

//fungsi Xlong int X(long int I) //definisi fungsi{

static long int F=I;

F = F * I; return(F);}

PENGIRIMAN PARAMETER Pengiriman paramater ke suatu fungsi

dapat dilakukan dengan dua cara, yaitu pengiriman secara nilai (by value) atau secara acuan (by reference).

Pengiriman secara nilai yang dikirimkan adalah nilai, sedangkan pengiriman secara acuan yang dikirimkan adalah alamat dari nilainya.

PENGIRIMAN SECARA NILAI Pengiriman parameter secara nilai mempunyai karakteristik:

1. Yang dikirimkan ke fungsi adalah nilai dari datanya, bukan alamat memori letak dari datanya.

2. Fungsi yang menerima kiriman nilai ini akan menyimpannya di alamat yang terpisah dari nilai aslinya yang digunakan oleh bagian program yang memanggil fungsi.

3. Karena alasan nomor 2 di atas, maka perubahan nilai di fungsi tidak akan merubah nilai asli di bagian program yang memanggil fungsi walaupun keduanya menggunakan nama variabel yang sama.

4. Pengirimannya searah, artinya dari bagian program yang memanggil fungsi ke fungsi yang dipanggil.

5. Pengiriman suatu nilai dapat dilakukan untuk suatu ungkapan, tidak hanya untuk sebuah variabel atau elemen larik atau konstanta saja.

/* ---------------------------------------------------------------------------------------- Nama Program: ADP_fungsi_6_pengiriman_parameter_byvalue.cpp Pengiriman Parameter Secara Nilai (by value) ---------------------------------------------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Secara_Nilai(float A, float B, char C); //prototype fungsi

main(){ char C = 'a'; float A = 25, *Alamat_A;

Alamat_A = &A;

printf("Contoh Program Pengiriman Parameter Secara Nilai\n"); printf("__________________________________________\n"); printf("\n");

Secara_Nilai(A, A/3, C); printf("Di fungsi utama setelah memanggil fungsi Secara_Nilai: \n"); printf("Nilai A adalah %f di alamat %p\n", A, Alamat_A); printf("Nilai A/3 adalah %f\n", A/3); printf("Nilai karakter C adalah %c\n", C); printf("\n");

system("pause");}

//fungsi Secara_Nilaivoid Secara_Nilai(float A, float B, char C) //definisi fungsi{

float *Alamat_A; Alamat_A = &A;

A = 7;

printf("Di fungsi Secara_Nilai: \n"); printf("Nilai A adalah %f di alamat %p\n", A, Alamat_A); printf("Nilai B adalah %f\n", B); printf("Nilai karakter C adalah %c\n\n", C);}

HASIL EKSEKUSI PROGRAM

PENGIRIMAN SECARA NILAI Dari hasil program contoh di atas dapat dijelaskan sebagai berikut:

1. Parameter-parameter aktual yang dikirimkan adalah nilai datanya, yaitu untuk variabel A, A/3 dan C sebagai berikut:

Secara_Nilai(A, A/3, C);

2. Variabel-variabel A dan C menempati memori berbeda untuk fungsi utama yang memanggil fungsi dan yang digunakan di fungsi Secara_Nilai(). Untuk fungsi utama, nilai variabel A disimpan di alamat 0012FF50, sedang di fungsi Secara_Nilai(), nilai variabel A disimpan di alamat memori 0012FF38.

3. Perubahan nilai variabel A di fungsi Secara_Nilai() menjadi bernilai 7 tidak merubah nilai variabel A di fungsi utama yang akan tetap bernilai 25.

4. Pengiriman suatu nilai merupakan pengiriman satu arah seperti terlihat berikut ini

5. Pengiriman secara nilai dapat mengirimkan suatu ungkapan, yaitu A/3

PENGIRIMAN SECARA ACUAN Pengiriman parameter secara acuan mempunyai karakteristik:

1. Yang dikirimkan ke fungsi adalah alamat letak dari nilai datanya, bukan nilai dari datanya.

2. Fungsi yang menerima kiriman alamat ini akan menggunakan alamat yang sama untuk mendapatkan nilai datanya.

3. Karena alasan nomor 2 di atas, maka perubahan nilai di fungsi akan merubah nilai asli di bagian program yang memanggil fungsi.

4. Pengiriman parameter secara acuan adalah pengiriman dua arah, yaitu dari bagian program yang memanggil fungsi ke fungsi yang dipanggil dan sebaliknya.

5. Pengiriman secara acuan tidak dapat dilakukan untuk suatu ungkapan, hanya untuk sebuah variabel atau elemen larik atau konstanta saja.

/* ---------------------------------------------------------------------------------------------- Nama Program: ADP_fungsi_7_pengiriman_parameter_byreference.cpp Pengiriman Parameter Secara Acuan (by reference) ------------------------------------------------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Secara_Acuan(float *A, float B, char *C); //prototype fungsi

main(){ char C = 'a'; float A = 25, *Alamat_A;

Alamat_A = &*A;

printf("Contoh Program Pengiriman Parameter Secara Reference\n"); printf("____________________________________________________\n"); printf("\n");

Secara_Acuan(&A, A/3, &C); printf("Di fungsi utama setelah memanggil fungsi Secara_Acuan: \n"); printf("Nilai A adalah %f di alamat %p\n", A, Alamat_A); printf("Nilai A/3 adalah %f\n", A/3); printf("Nilai karakter C adalah %c\n", C); printf("\n");

system("pause");}

//fungsi Secara_Acuanvoid Secara_Acuan(float *A, float B, char *C) {

float *Alamat_A; Alamat_A = &A;

*A = 7;

printf("Di fungsi Secara_Acuan: \n"); printf("Nilai A adalah %f di alamat %p\n", *A, Alamat_A); printf("Nilai B adalah %f\n", B); printf("Nilai karakter C adalah %c\n\n", *C);}

HASIL EKSEKUSI PROGRAM

PENGIRIMAN SECARA ACUAN Pengiriman parameter secara acuan adalah pengiriman

alamat dari nilai datanya dan telah diketahui bahwa alamat dari suatu nilai data dapat diperoleh dengan menggunakan operator ‘&’ seperti tampak di parameter-parameter aktual untuk variabel A dan C. Parameter aktual A/3 dikirimkan secara nilai, karena pengiriman secara acuan tidak dapat menggunakan suatu ungkapan. Karena yang dikirimkan adalah alamatnya, maka parameter-parameter formal di definisi fungsi harus dalam bentuk pointer. Variabel pointer dapat dideklarasikan dengan menuliskan nama variabelnya diawali dengan asterik (‘*’). Hubungan antara parameter aktual dan parameter formal adalah hubungan dua arah seperti berikut:

PENGIRIMAN SECARA ACUAN Karena hubungan dua arah ini, maka

perubahan nilai di fungsi akan mengakibatkan perubahan nilai di bagian program yang memanggilnya. Di contoh program ADP_fungsi_7_pengiriman_parameter_byreference.cpp, nilai di alamat variabel A dirubah dengan nilai 7 di fungsi Secara_Acuan(). Akibatnya nilai variabel A di fungsi utama juga berubah dari nilai 25 menjadi 7.

PENGIRIMAN SECARA ACUAN Contoh

ADP_fungsi_7a_pengiriman_parameter_byreference.cpp berikut ini menunjukkan dengan jelas bahwa perubahan nilai di fungsi untuk parameter yang dikirimkan secara acuan akan merubah juga nilai di bagian program yang memanggilnya. Karena sifat dua arah ini, maka pengiriman parameter secara acuan dapat juga dipakai sebagai pengganti hasil balik dari fungsi. Di contoh ini, parameter aktual C akan mengirimkan alamatnya ke fungsi Tambah(). Setelah proses dari fungsi Tambah() selesai, alamat ini akan berisi dengan hasil proses fungsi, sehingga dapat digunakan di bagian program yang memanggilnya sebagai hasil yang diperoleh dari fungsi yang dipanggil.

/* --------------------------------------------------------------------------------------------------- Nama Program: ADP_fungsi_7a_pengiriman_parameter_byreference.cpp Pengiriman Parameter Secara Acuan (by reference) --------------------------------------------------------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Tambah(int *A, int *B, int *C); //prototype fungsi

main(){ int A = 2, B = 3, C;

printf("Contoh Program Pengiriman Parameter Secara Reference\n"); printf("_______________________________________________\n"); printf("\n");

Tambah(&A, &B, &C); printf("%d di tambah %d adalah %d\n", A, B, C); printf("\n");

system("pause");}

//fungsi Secara_Acuanvoid Tambah(int *A, int *B, int *C) //definisi fungsi{

*C = *A + *B; return; }

HASIL EKSEKUSI PROGRAM

/* --------------------------------------------------------------------------------------------------- Nama Program: ADP_fungsi_7b_pengiriman_parameter_byreference.cpp Pengiriman Parameter Secara Acuan (by reference) --------------------------------------------------------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>int *Tambah(int *A, int *B); //prototype fungsi

main(){ int A = 2, B = 3, *C;

printf("Contoh Program Pengiriman Parameter Secara Reference\n"); printf("____________________________________________________\n"); printf("\n");

C = Tambah(&A, &B); printf("%d di tambah %d adalah %d\n", A, B, *C); printf("\n");

system("pause");}

//fungsi Secara_Acuanint *Tambah(int *A, int *B) //definisi fungsi{ int Hasil;

Hasil = *A + *B; return(&Hasil);}

HASIL EKSEKUSI PROGRAM

PENGIRIMAN SECARA ACUAN Contoh program

ADP_fungsi_7a_pengiriman_parameter_byreference.cpp dapat juga dirubah dengan hasil balik dari fungsi yang merupakan hasil balik berupa suatu pointer yang dikirimkan dengan statemen return.

Di fungsi Tambah(), hasil yang dikirimkan adalah berupa alamat dari variabel Hasil. Alamat dari variabel ini ditunjukkan oleh &Hasil. Dengan demikian, fungsi Tambah() ini harus dideklarasikan dengan bentuk pointer dengan cara nama dari fungsinya ditulis diawali oleh asterik (‘*’). Di bagian program yang memanggil fungsi, hasil dari fungsi ini juga harus diterima oleh suatu variabel pointer, yaitu C yang sudah harus dideklarasikan sebagai variabel pointer.

PENGIRIMAN PARAMETER Dengan pengiriman secara parameter (secara nilai

atau acuan), maka variabel-variabel yang dikirimkan tidak perlu dideklarasikan lagi di fungsi yang menerimanya. Di contoh program ADP_fungsi_6_pengiriman_parameter_byvalue.cpp, parameter aktual A, A/3, dan C dikirimkan dan akan diterima oleh parameter-parameter formal A, B, dan C. Di definisi fungsi, parameter-parameter formal ini telah dideklarasikan yang masing-masing bertipe float, float, dan char. Nama-nama parameter formal dapat berbeda dengan nama-nama parameter aktualnya.

REKURSI

Rekursi (recursion) adalah suatu proses dari fungsi yang memanggil dirinya sendiri secara berulang-ulang.

Karena proses dilakukan berulang-ulang, maka harus ada suatu kondisi yang mengakhiri prosesnya. Jika tidak, maka proses tidak akan pernah berhenti sampai memori yang digunakan tidak dapat menampung lagi.

/* ---------------------------------------------- Nama Program: ADP_rekursi.cpp Rekursi ---------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Terus_Tidak_Berhenti(void); //prototype fungsi

main(){ printf("Contoh Program Rekursi\n"); printf("______________________\n"); printf("\n");

Terus_Tidak_Berhenti(); printf("\n");

system("pause");}

//fungsi menampilkan hasil terus tidak berhentivoid Terus_Tidak_Berhenti(void) //definisi fungsi{

printf("Ctrl-Break untuk berhenti\n"); Terus_Tidak_Berhenti();}

HASIL EKSEKUSI PROGRAM

REKURSI

Contoh program ADP_rekursi.cpp di atas merupakan program rekursi yang tidak akan berhenti karena tidak mempunyai kondisi yang menghentikan prosesnya. Proses rekursi ini ditunuukkan oleh statemen Terus_Tidak_Berhenti(), yaitu proses yang memanggil fungsi dirinya sendiri (perhatikan bahwa statemen ini berada di dalam fungsi yang dipanggil).

/* ------------------------------------------------- Nama Program: ADP_rekursi_1.cpp Rekursi -------------------------------------------------- */

#include <stdio.h>#include <stdlib.h>void Berhenti_N_Kali(int N); //prototype fungsi

main(){ int N=3;

printf("Contoh Program Rekursi\n"); printf(“____________________\n"); printf("\n");

Berhenti_N_Kali(N); printf("\n");

system("pause");}//fungsi menampilkan hasil sebanyak N Kalivoid Berhenti_N_Kali(int N) //definisi fungsi{ static int I=0;

if(N<=0)return;printf("%d kali\n", ++I);

Berhenti_N_Kali(N-1);}

HASIL EKSEKUSI PROGRAM

REKURSI

Proses rekursi di program ADP_rekursi_1.cpp mempunyai kondisi pengakhiran rekursi, yaitu jika nilai N sudah lebih kecil atau sama dengan nol. Setiap kali fungsi memanggil dirinya sendiri, nilai dari N dikurangi dengan nilai 1, sehingga nilai N akhirnya akan menjadi nol dan proses rekursi akan diakhiri, sehingga fungsi ini akan memanggil dirinya sendiri sebanyak N kali.

/* ------------------------------------------------ Nama Program: ADP_rekursi_2.cpp Rekursi ------------------------------------------------ */#include <stdio.h>#include <stdlib.h>long int Fak_Rekursi(int N); //prototype fungsi

main(){ int N=5;

printf("Contoh Program Rekursi\n"); printf(“____________________\n"); printf("\n");

printf("%d faktorial = %ld\n", N, Fak_Rekursi(N)); printf("\n"); system("pause");}//fungsi rekursi menghitung N Faktoriallong int Fak_Rekursi(int N) //definisi fungsi{ long int F;

if(N<=1)return(1); else{ F = N * Fak_Rekursi(N-1); return(F);

}}

HASIL EKSEKUSI PROGRAM

REKURSI Proses rekursi di program ADP_rekursi_2.cpp dapat dijelaskan sebagai berikut:1. Fungsi utama memanggil fungsi Fak_Rekursi() dengan mengirimkan nilai 5 untuk

parameter aktual N, yang maksudnya akan dilakukan perhitungan sebanyak 5 faktorial.

2. Jika nilai dari N pertama kali yang diberikan oleh fungsi utama bernilai kurang atau sama dengan satu, maka hasil faktorial yang akan diberikan adalah bernilai 1.

3. Jika nilai N pertama kali yang diberikan oleh fungsi utama lebih besar dari 1, maka proses rekursi yang pertama adalah:

F = 5 * Fak_Rekursi(4);Proses ini akan memanggil kembali fungsi dirinya sendiri dengan mengirimkan nilai sebagai nilai N yang baru. Karena nilai N masih lebih besar dari 1, maka proses rekursi ke dua akan dilakukan dengan hasilnya adalah 4 * Fak_Rekursi(3). Untuk N adalah 3, hasil yang diperoleh oleh rekursi adalah 3 * Fak_Rekursi(2) dan seterusnya sampai nilai N adalah 1. Untuk nilai N sama dengan 1 ini, statemen return(1) akan mengembalikan proses ke bagian yang memanggilnya, yaitu statemen setelah statemen F = 5 * Fak_Rekursi(N-1). Statemen return(F) kemudian baru mengembalikan proses ke fungsi utama. Hasil akhirs nilai F dari penjelasan di atas untuk 5 faktorial dapat dituliskan seperti di slide berikut:

PUSTAKA

Kristanto, Andri. (2009). Algoritma & Pemrograman dengan C++ Edisi 2. Yogyakarta. Graha Ilmu.

Hartono, Jogiyanto, MBA., Ph.D. (2002). Konsep Dasar Pemrograman Bahasa C. Yogyakarta. Andi.