View
234
Download
1
Category
Preview:
DESCRIPTION
Algoritma dan pemrograman
Citation preview
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.
Fungsi – Algoritma & Pemrograman
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"
using namespace std;
Fungsi – Algoritma & Pemrograman
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);
Fungsi – Algoritma & Pemrograman
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"
using namespace std;
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:
Fungsi – Algoritma & Pemrograman
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//*------------------------------------------------------------------------
Fungsi – Algoritma & Pemrograman
87
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
using namespace std;
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 ()
Fungsi – Algoritma & Pemrograman
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//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
using namespace std;
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){
Fungsi – Algoritma & Pemrograman
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;
_getch();}// definisi fungsivoid tambah(void){
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();
Fungsi – Algoritma & Pemrograman
90
cout << "nilai i kini = " << i <<endl;
_getch();}// definisi fungsivoid tambah(void){
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>
Fungsi – Algoritma & Pemrograman
91
#include "conio.h"#include "iomanip"#include "stdio.h"
using namespace std;
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.
Fungsi – Algoritma & Pemrograman
92
//*------------------------------------------------------------------------// program 6.7 efek pemakaian variabel register//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
using namespace std;
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//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
using namespace std;
Fungsi – Algoritma & Pemrograman
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//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
using namespace std; void ulang(char karakter = '-', int jum =10);void main (){
ulang ('*', 5);ulang ('-');ulang ('+');
_getch();}void ulang (char karakter , int jum){
Fungsi – Algoritma & Pemrograman
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//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
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;
Fungsi – Algoritma & Pemrograman
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;
Fungsi – Algoritma & Pemrograman
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//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
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
Fungsi – Algoritma & Pemrograman
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//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
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.
Fungsi – Algoritma & Pemrograman
98
//*------------------------------------------------------------------------// program 6.11 Rekursi//*------------------------------------------------------------------------
#include <iostream>#include "conio.h"#include "iomanip"#include "stdio.h"
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)
Fungsi – Algoritma & Pemrograman
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)
Fungsi – Algoritma & Pemrograman
Recommended