ALGORITMA 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) /*tidak diakhiri titik koma*/
float A; /*diakhiri titik koma*/
int B; /*diakhiri titik koma*/
char C; /*diakhiri titik koma*/
{
/*tubuh fungsi*/
}
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 negatip

double 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 dahulu
double 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.cp
p, 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 string

void 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 string

void 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 faktorial

long 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 penambahan

float 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 global

main()
{
printf("Contoh Program Variabel Global Fungsi\n");
printf("_____________________________________\n");
printf("\n");

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

system("pause");
}

//fungsi menghitung penambahan

float 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 X
long 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.
/* ---------------------------------------------------------------------------------------- //fungsi Secara_Nilai
Nama Program: ADP_fungsi_6_pengiriman_parameter_byvalue.cpp void Secara_Nilai(float A, float B, char C) //definisi fungsi
Pengiriman Parameter Secara Nilai (by value) {
---------------------------------------------------------------------------------------- */ float *Alamat_A;
Alamat_A = &A;
#include <stdio.h>
#include <stdlib.h> A = 7;
void Secara_Nilai(float A, float B, char C); //prototype fungsi
printf("Di fungsi Secara_Nilai: \n");
main() printf("Nilai A adalah %f di alamat %p\n", A, Alamat_A);
{ printf("Nilai B adalah %f\n", B);
char C = 'a'; printf("Nilai karakter C adalah %c\n\n", C);
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");
}
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.
/* ---------------------------------------------------------------------------------------------- //fungsi Secara_Acuan
Nama Program: ADP_fungsi_7_pengiriman_parameter_byreference.cpp void Secara_Acuan(float *A, float B, char *C)
Pengiriman Parameter Secara Acuan (by reference) {
------------------------------------------------------------------------------------------- */ float *Alamat_A;
Alamat_A = &A;
#include <stdio.h>
#include <stdlib.h> *A = 7;
void Secara_Acuan(float *A, float B, char *C); //prototype fungsi
printf("Di fungsi Secara_Acuan: \n");
main() printf("Nilai A adalah %f di alamat %p\n", *A, Alamat_A);
{ printf("Nilai B adalah %f\n", B);
char C = 'a'; printf("Nilai karakter C adalah %c\n\n", *C);
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");
}
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_paramete
r_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_byre
ference.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_Acuan
void 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_Acuan
int *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_byreferenc
e.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_by
value.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 berhenti

void 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 Kali
void 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 Faktorial
long 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.