Bab Vi Fungsi

BAB VI

FUNGSI

6.1. Pengantar Fungsi

Sejumlah fungsi berisi sejumlah pernyataan yang dikemas dalam sebuah

nama. Fungsi adalah suatu bagian program yang dirancang untuk melaksanakan

tugas tertentu dan letaknya dipisahkan dari program yang menggunakannya.

Elemen utama dari program visual C++ berupa fungsi-fungsi, dalam hal ini

program dari bahasa C ++ dibentuk dari kumpulan fungsi pustaka (standar) dan

fungsi yang dibuat sendiri oleh pemrogram. Tujuan penggunaan fungsi adalah:

1. Program menjadi terstruktur, sehingga mudah dipahami dan mudah

dikembangkan. Dengan memisahkan langkah-langkah detail ke satu atau

lebih fungsi-fungsi, maka fungsi utama (main()) menjadi lebih pendek,

jelas dan mudah dimengerti.

2. Mengurangi perulangan (duplikasi)kode. Langkah-langkah program yang

sama dan dipakai beulang-ulang diprogram dapat ditulis sekali saja secara

terpisah dalam bentuk fungsi-fungsi. Selanjutnya bagian program yang

membutuhkan langkah-langkah ini tidak perlu selalu menuliskannya,

tetapi cukup memanggil fungsi-fungsi tersebut

6.2. Dasar Fungsi

Fungsi standard C yang mempunyai tugas khusus adalah:

Cout untuk menampilkan informasi atau data ke layar

Cin untuk membaca kode tombol yang diinputkan.

Pada umumnya fungsi memerlukan nilai masukan atau parameter yang

disebut argumen. Nilai masukan ini akan diolah oleh fungsi. Hasil akhir fungsi

berupa sebuah nilai (disebut sebagai return value atau nilai keluaran fungsi). Oleh

karena itu fungsi digambarkan sebuah “kotak gelap” seperi pada gambar 6.1.

80

81

Gambar 6.1 Fungsi sebagai sebuah kotak gelap

Penggambaran sebagai kotak gelap diantaranya menjelaskan bahwa bagian

dalam fungsi bersifat pribadi bagi fungsi. Tak ada suatu pernyataan diluar fungsi

yang bisa mengakses bagian dalam fungsi, selain melaui parameter. Misalnya

melakukan go to dari pernyataan diluar fungsi ke pernyatan dalam fungsi adalah

tidak diperkenalkan.

Bentuk umum dari defini sebuah fungsi adalah sebagai berikut:

Keterangan :

Tipe keluaran fungsi, dapat berupa salah satu tipe data C++, misalnya char

atau int. Kalau penentu tipe tidak disebutkan maka dianggap bertipe int

(secara default).

Tubuh fungsi berisi deklarasi veriabel (kalau ada) dan statemen-statemen

yang akan melakukan tugas yang akan diberikan kepada fungsi yang

bersangkutan. Tubuh fungsi ini ditulis dalam tanda kurung kurawal buka

dan kurung kurawal tutup.

Sebuah fungsi yang sederhana bisa saja tidak mengandung parameter sama sekali

dan tentu saja untuk keadaan ini deklarasi parameter juga tidak ada. Contohnya;

Int inisialisasi ()

{

Return(0);

}

Fungsi – Algoritma & Pemrograman

Tipe-keluaran-fungsi nama-fungsi (deklarasi argumen)

{

Tubuh fungsi

}

82

Inisialisasi ()

{

Return(0);

}

Pada fungsi diatas:

Tipe keluaran fungsi tidak disebutkan, berarti keluaran fungsi ber tipe int.

Inisialisasi adalah nama fungsi

Tanda () sesudah nama fungsi menyatakan bahwa fungsi tak memiliki

parameter.

Tanda { dan } adalah awal dan akhir fungsi.

Return (0) merupakan sebuah pernyataan dalam tubuh fungsi.

Gambar 6.2 Penjelasan definisi sebuah fungsi

6.3. Memberikan Nilai Keluaran Fungsi

Suatu fungsi dibuat untuk menyelesaikan tugas tertentu. Suatu fungsi

hanya melakukan suatu tugas saja tanpa memberikan suatu hasil keluaran atau

melakukan suatu tugas dan kemudian memberikan hasil keluaran. Fungsi yang

hanya melakukan suatu tugas saja tanpa memebarikan hasil keluaran misalnya

adalah fungsi untuk menampilkan hasil dilayar.

Dalam tubuh fungsi, pernyataan yang digunakan untuk memberikan nilai

keluaran fungsi berupa return. Sebagai contoh, pada fungsi inisialisasi() diatas

terdapat pernyataan:

Return (0);

Merupakan pernyataan untuk memberikan nilai keluaran fungsi berupa nol.

Program 6.1 menunjukan fungsi sebuah fungsi yaitu berupa fungsi kuadrat dengan

tipe long.


83

//*-----------------------------------------------------------------------// program 6.1 fungsi dengan argumen dan nilai balik bertipe long//*------------------------------------------------------------------------#include <iostream>#include "conio.h"#include "iomanip"

using namespace std;

long kuadrat (long l);void main (){

for (long bil = 200; bil <2000; bil+=200)cout << setw(8) << bil << setw(8) << kuadrat(bil) <<

endl;_getch();

}// definisi fungsilong kuadrat (long l){

return (l*l);_getch();

}

Keluarannya:

Contoh lain penggunaan fungsi adalah untuk menentukan nilai maksimum dari

dua buah nilai.//*------------------------------------------------------------------------// program 6.2 fungsi untuk mencari nilai terkecil dari 2 buah nilai//*------------------------------------------------------------------------

#include <iostream>#include "conio.h"#include "iomanip"



84

int minimum(int,int);

void main (){

int a, b, kecil;cout << "Masukkan nilai a : ";cin >> a;

cout << "Masukkan nilai b : ";cin >> b;

kecil = minimum(a,b);

cout << "Bilangan terkecil antara : " << a << "dan " << b << "adalah = "<< kecil <<endl;

_getch();}int minimum(int x, int y){

if (x < y)return(x);

elsereturn(y);

}Keluarannya:

6.4. Prototipe Fungsi

Prototipe fungsi digunakan untuk menjelaskan kepada kompiler mengenai:

Tipe keluaran fungsi

Jumlah parameter

Tipe dari masing-masing parameter

Bagi kompiler, informasi dalam prototipe akan dipakai untuk menerima

keabsahan (validitas) parameter dalam pemanggilan fungsi. Salah satu

keuntungannya adalah kompiler akan melakukan konversi seandainya antara tipe

parameter dalam fungsi dan parameter saat pemanggilan fungsi tidak sama atau

akan menunjukkan kesalahan bila jumlah parameter dalam definisi dan saat

pemanggilan berbeda.float jumlah(float x,float y);


85

atau float jumlah(float,float);

penjelasannya:

Gambar 6.3 Prototipe fungsi

Program 6.3 menunjukkan contoh pemakaian prototipe float//*------------------------------------------------------------------------// program 6.3 pemakaian prototipe fungsi//*------------------------------------------------------------------------

#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"


float jumlah(float,float);

void main (){

float a, b, c;cout << "Masukkan nilai a : ";cin >> a;

cout << "Masukkan nilai b : ";cin >> b;

c = jumlah(a,b);

cout << "Hasil Penjumlahan antara : " << a << "dan " << b << "adalah = "<< c <<endl;

_getch();}float jumlah(float x, float y){

return(x+y);}

Keluaranya:


86

6.5. Penggolongan Variabel

Pemahaman terhadap lingkup variabel didalam penulisan fungsi sangatlah

penting, agar tidak salah dalam menggunakan suatu variabel. Penggolongan

variabel menentukan keberadaan suatu variabel tertentu didalam fungsi.

Penggolongan variabel berdasarkan kelas penyimpanannya antara lain:

1. Variabel otomatis

2. Variabel eksternal

3. Variabel statis

6.5.1. Variabel Otomatis

Variabel yang didefinisikan didalam suatu fungsi berlaku sebagai variabel

lokal bagi fungsi. Artinya variabel tersebut hanya dikenal didalam fungsi tempat

variabel didefinisikan, sebagai contoh:

Void alpha()

{

Int x =20;

Double y = 3.14;

Cout << “pada alpha () : x = ” << x

<< “y= “ << y << endl;

}

Program 6.4 menunjukkan contoh pemakaian variabel lokal.//*------------------------------------------------------------------------// program 6.4 efek pemakaian variabel lokal atau otomatis//*------------------------------------------------------------------------


87



void alpha(); // prototipe fungsi

void main (){

int x=22; // variabel lokal pada main()double y=2.22; // variabel lokal pada main()

cout << "pada main() : x = " << x << endl;cout << "y = " << y << endl;alpha (); //panggil fungsi alpha

cout << "pada main() : x = " << x <<endl; cout << "y= " << y << endl;

_getch();}// definisi fungsivoid alpha(){

int x = 20; // variabel lokal pada alpha () double y = 3.14; // variabel lokal pada alpha ()

cout << "pada alpha () : x = " << x <<endl;cout <<"y = " << y << endl;

}

Keluarannya:

Perubahan x dan y pada alpha() tidak mempengaruhi variabel bernama sama pada

main(). Ini membuktikan bahwa variabel-variabel tersebut bersifat lokal bagi

masing-masing fungsi yang mendefinisikannya.

Variabel x dan y pada fungsi alpha () disebut sebagai variabel otomatis

(begitu juga pada main()). Variabel ini dapat ditulis dengan awalan berupa kunci

auto, bentuk lain penulisan program adalah sebagai berikut:void alpha(){

auto int x = 20; // variabel lokal pada alpha ()


88

auto double y = 3.14; // variabel lokal pada alpha ()

cout << "pada alpha () : x = " << x <<endl;cout <<"y = " << y << endl;

}

6.5.2. Variabel eksternal

Variabel eksternal merupakan kebalikan dari variabel otomatis. Variabel

eksternal adalah variabel yang didefinisikan diluar fungsi manapun. Variabel ini

dikenal juga sebagai variabel global, dikenal disemua fungsi. Sifat dari variabel

eksternal:

Dapat diakses oleh semua fungsi

Kalau tidak diberi nilai, secara otomatis diinisialisasi dengan nilai sama

dengan nol.

Program 6.5 menunjukkan contoh fungsi variabel eksternal.//*------------------------------------------------------------------------// program 6.5 efek pemakaian variabel eksternal//*------------------------------------------------------------------------



int i=273; // variabel eksternalvoid tambah(void);

void main (){

cout << "nilai awal i = " << i << endl;i +=7;cout << "nilai i kini = " << i << endl;tambah(); cout << "nilai i kini = " << i <<endl; tambah();cout << "nilai i kini = " << i <<endl;

_getch();}// definisi fungsivoid tambah(void){


89

i++;}

Keluarannya:

Dari program 6.5 terlihat bahwa i hanya dideklarasikan dibagian atas program,

dan tidak dideklarasikan lagi dalam fungsi main() maupun tambah (). Oleh karena

itu i merupakan variabel eksternal maka dapat digunakan oleh kedua fungsi

tersebut. Namun ada satu hal yang perlu diketahui, variabel eksternal haruslah

dideklarasikan sebelum definisi yang akan mempergunakannya. Program 6.5b

memperjelas penggunaan variabel eksternal dengan menambahkan kata kunci

extern didepan tipe data variabel.void main (){

extern int i; // variabel ekternalcout << "nilai awal i = " << i << endl;i +=7;cout << "nilai i kini = " << i << endl;tambah(); cout << "nilai i kini = " << i <<endl; tambah();cout << "nilai i kini = " << i <<endl;


extern int i;i++;

}Sedangkan untuk membedakan variabel lokal dengan variabel eksternal dapat

ditulis seperti pada program 6.5c.void main (){

extern int i; // variabel ekternalcout << "nilai awal i = " << i << endl;i +=7;cout << "nilai i kini = " << i << endl;tambah(); cout << "nilai i kini = " << i <<endl; tambah();


90

cout << "nilai i kini = " << i <<endl;


int i; // variabel lokali++;

}

6.5.3. Variabel statis

Variabel statis dapat berupa variabel internal (didefinisikan didalam

fungsi) maupun variabel eksternal, sifat variabel statis adalah sebagai berikut:

Kalau variabel statis bersifat internal, maka variabel hanya dikenal oleh

fungsi tempat variabel dideklarasikan.

Kalai variabel statis bersifat eksternal, maka variabel dapat dipergunakan

oleh semua fungsi yang terletak pada file yang sama, tempat variabel statis

dideklarasikan.

Berbeda dengan variabel lokal, variabel statis tidak akan hilang

sekeluarnya dari fungsi (nilai pada variabel akan tetap diingat).

Inisialisasi akan dilakukan hanya sekali, yaitu saat dipanggil yang pertama

kali. Kalau tidak ada inisialisasi oleh pemrogram secara otomatis akan

diberi nilai awal nol.

Variabel statis diperoleh dengan menambahkan kata kunci statisc didepan tipe

data variabel, seperti pada program 6.6.//*------------------------------------------------------------------------// program 6.6 efek pemakaian variabel statis//*------------------------------------------------------------------------

#include <iostream>


91

#include "conio.h"#include "iomanip"#include "stdio.h"


void fungsi_y(void);

void main (){

int y =20; // variabel lokalfungsi_y();fungsi_y();

cout << "nilai y dalam main() = " << y << endl;

_getch();}// definisi fungsivoid fungsi_y(void){

static int y; // variabel statisy++;cout << "nilai y dalam fungsi_y() = " << y << endl;

}

Pada program 6.6 terlihat bahwa variabel statis dijalankan terlebih dahulu dengan

memanggil fungsi_y dengan kenaikan nilai sebesar 1 sebayak 2 kali, kemudian

nilai fungsi_y dalam main adalah nilai dari variabel lokal.

6.5.4. Variabel Register

Variabel register adalah variabel yang nilainya disimpan dalam register

dan bukan dalam memori RAM. Variabel yang seperti ini hanya bisa diterapkan

pada variabel yang lokal atau parameter formal, yang bertipe char atau int.

Variabel register biasa diterapkan pada variabel yang digunakan sebagai

pengendali loop. Tujuannya utnuk mempercepat proses dalam loop. Sebab

variabel yang diopersikan pada register memiliki kecepatan yang jauh lebih tinggi

daripada variabel yang diletakkan pada RAM. Program 6.7 menunjukkan

pemakaiannya variabel register.


92

//*------------------------------------------------------------------------// program 6.7 efek pemakaian variabel register//*------------------------------------------------------------------------



void main (){

register int i; // variabel lokalint jumlah = 0;for (i = 1; i <= 100; i++)

jumlah = jumlah + i;cout << "nilai 1+2+3+....+100 = " << jumlah << endl;

_getch();}

6.6. Nilai Bawaan untuk Argumen Fungsi

Bahasa C++ mempunyai kemampuan untuk menyetel nilai bawaan

(default) argumen fungsi. Argumen-argumen yang mempunyai nilai bawaan

nantinya tidak dapat disertakan didalam pemanggilan fungsi dan dengan

sendirinya C++ akan menggunakan nilai bawaan dari argumen yang tidak

disertakan. Program 6.8 menunjukkan contoh nilai bawaan untuk argumen fungsi.//*------------------------------------------------------------------------// program 6.8 efek pemakaian nilai bawaan//*------------------------------------------------------------------------




93

void tulis_cplus(int jum);void main (){

tulis_cplus(10);

_getch();}void tulis_cplus(int jum){

for (int i=0; i<jum; i++)cout << "belajar C++" << endl;

cout << "selesai" << endl;}

Fungsi diatas akan menampilkan tulisan belajar C++ sebanyak jum kali. Setelah

menampilkan tulisan tersebut, fungsi akan menampilkan tulisan “selesai”.

//*------------------------------------------------------------------------// program 6.8 mengatur nilai bawaan terhadap argumen pada fungsi yang memiliki 2 argumen//*------------------------------------------------------------------------


using namespace std; void ulang(char karakter = '-', int jum =10);void main (){

ulang ('*', 5);ulang ('-');ulang ('+');

_getch();}void ulang (char karakter , int jum){


94

for (int i=0; i<jum; i++)cout << karakter ;

cout << endl;

}

6.7. Referensi

Pada C++ referensi digunakan untuk memberikan nama alias variabel.

Bentuk pendeklarasiannya:

Tanda & mengawali nama referensi.

Program 6.9 menunjukkan contoh penggunaan referensi.//*------------------------------------------------------------------------// program 6.9 referensi//*------------------------------------------------------------------------


using namespace std; void main (){

int i;int &r = i; // r referensi dari i

r=77;cout << "nilai : r = " << r << " , i = " << i << endl;cout << "alamat : r = " << &r << " , i = " << &i << endl;

int j=88; // menciptakan variabel j

r=j;cout << "nilai : r = " << r << " , i = " << i << " , j =

" << j << endl;cout << "Alamat : r = " << &r << " , i = " << &i << " , j =

" << &j << endl;


Int &ref = nama_variabel;

95

_getch();}Keluarannya:

Tanda & perlu diberikan didepan variabel untuk menyatakan alamat, r = j, tidak

berarti bahwa r sekarang merupakan referensi dari variabel j, melainkan nilai r

kini diisi dengan nilai j. Dengan kata lain, alamat dari r tetap sama dengan alamat

i dan sudah tentu berbeda dengan alamat j.

6.8. Inline Function

Fungsi digunakan didalam program diantaranya adalah untuk membentuk

program yang terstruktur. Namun pemakaian fungsi kadang-kadang harus dibayar

mahal. Sebab argumen-argumen fungsi harus diletakkan didalam stack pada saat

pemanggilan fungsi. Kemudian pada saat fungsi berakhir, argumen-argumen

yang ada pada stack perlu dikosongkan lagi. Sebagai akibatnya akan

memperlambat eksekusi, terutama kalau fungsi sering dipanggil (terutama pada

pengulangan proses dengan while).

Masalah tersebut bisa diatasi dengan menggunakan inline function.

Sebuah inline function dibentuk dengan cukup menyisipkan kunci-kunci inline

didepan tipe nilai balik fungsi dalam pendefinisian fungsi. Contoh :

Inline jumlah(int x, int y)

{ return(x+y);

}

Inline function disarankan dipakai pada fungsi yang sering dipanggil dan

ukurannya kecil (terdiri dari satu atau dua pernyataan), terutama jika dilibatkan

pada pernyataan pengulangan proses (while, for dan do-while). Misalnya pada

bentuk seperti berikut:

For (int i = 1; i < 100; i ++)

Cout << i << “ . ” << jumlah (i, 2*i) << endl;


96

Jika fungsi jumlah() tidak ditulis sebagai inline function, maka proses tersebut

akan menjadi lambat.

Program 6.10 menunjukkan contoh penggunaan inline function.//*------------------------------------------------------------------------// program 6.10 Inline function//*------------------------------------------------------------------------


using namespace std; int i;inline int jumlah(int x, int y){

return(x + y);}void main (){

for (int i = 1; i < 100; i++)cout << i <<". " << jumlah (i, 2*i) << endl;

_getch();}Keluarannya:

6.9. Rekursi

Fungsi dalam bahasa C dipakai secara rekursi, dalam artian suatu fungsi

dapat memanggil dirinya sendiri. Sebagai contoh penerapan fungsi rekursi untuk

menghitung nilai:

Xn

Dengan n berupa bilangan bulat positif. Solusi dari persoalan ini dapat berupa:

Jika n=1, maka xn =x


97

Selain itu maka xn = x *xn-1

Misalnya x=2 dan n=3, proses pemecahannya adalah:

Program 6.11 menunjukkan pemakaian rekursi untuk menghitung nilai pangkat.//*------------------------------------------------------------------------// program 6.11 rekursi pangkat//*------------------------------------------------------------------------


using namespace std; long int pangkat(int x, int n);

void main (){

int x, y;cout <<"MENGHITUNG nilai x^y" <<endl;cout << "Masukkan nilai x bilangan positif : " ;cin >> x;cout << "Masukkan nilai y bilangan positif : " ;cin >> y;

cout << x << " ^ "<< y << " = " << pangkat(x,y) << endl; _getch();}Keluarannya:

Contoh lain untk menghitung nilai faktorial.


98

//*------------------------------------------------------------------------// program 6.11 Rekursi//*------------------------------------------------------------------------


using namespace std; int faktorial(int);

void main (){

int x;cout <<"MENGHITUNG FAKTORIAL DARI X!" <<endl;cout << "Masukkan nilai x bilangan positif : " ;cin >> x;

cout << "Faktorial dari x : " << x << " ! = " << faktorial(x) << endl; _getch();}int faktorial (int m){

if(m==1)return(1);

elsereturn(m*faktorial(m-1));

_getch();}

Keluarannya:

Biasanya rekursi akan menjadikan fungsi sulit untuk dimengerti. Hanya cocok

untuk persoalan tertentu saja (misalnya pada binary tree atau pohon biner). Untuk

fungsi rekursi pada program rekursi faktorial akan mudah dipahami kalau ditulis

sebagai barikut:int faktorial (int m)


99

{int i, fak;fak = 1;for (i=1; i<=m; i++)

fak =fak*i;return(fak);//if(m==1)

//return(1);//else

//return(m*faktorial(m-1));

_getch();}

Rekursi memerlukan stack dengan ukuran yang lebih besar. Sebab setiap kali

fungsi dipanggil, variabel lokal dan parameter formal akan ditempatkan ke stack

dan adakalanya akan menyebabkan stack tak cukup lagi (stack overflow)


Bab Vi Fungsi

Documents