Fungsi
Fungsi (Function)
merupakan blok dari kode yang dirancang untuk
melaksanakan tugas
khusus. Kegunaan dari fungsi ini adalah untuk:
- Mengurangi
pengulangan penulisan program yang berulangan atau sama.
- Program
menjadi lebih terstruktur, sehingga mudah dipahami dan dapat lebih
dikembangkan.
Fungsi-fungsi yang
sudah kita kenal sebelumnya adalah fungsi main(), yang
bersifat mutlak,
karena fungsi ini program akan dimulai, sebagai contoh yang lainnya
fungsi printf(),
cout() yang mempunyai tugas untuk menampilkan informasi atau data
9.1.
Struktur Fungsi
Sebuah fungsi
sederhana mempunyai bentuk penulisan sebagai berikut:
Keterangan:
- Nama fungsi,
boleh dituliskan secara bebas dengan ketentuan, tidak
menggunakan spasi dan
nama-nama fungsi yang mempunyai arti sendiri.
- Argumen,
diletakan diantara tanda kurung “( )” yang terletak dibelakang nama
fungsi. Argumen boleh
diisi dengan suatu data atau dibiarkan kosong.
- Pernyataan /
perintah, diletakan diantara tanda kurung ‘{ }’.
Pada
pemanggilan sebuah fungsi, cukup dengan menuliskan nama
fungsinya.
Contoh pembuatan
fungsi sederhana
Contoh-1
/* pembuatan fungsi garis() */
#include
#include
#include
garis( )
{
printf("\n----------------------\n");
}
BORLAND
C++
9
nama_fungsi(argumen)
{
…
pernyataan / perintah;
…
pernyataan / perintah;
…
pernyataan / perintah;
}
/* program utama */
main( )
{
clrscr( );
garis( ); //memanggil
fungsi garis
cout<<"AMIK
BSI - Pondok Labu"<
garis( ); //memanggil
fungsi garis
getche( );
}
Output yang akan
dihasilkan, dari program contoh-1 diatas adalah:
Gambar
9.1. Hasil Contoh-1
9.2.
Prototipe dan Parameter Fungsi
Prototipe merupakan
uraian dari blok fungsi yang dapat digunakan untuk
mendeklarasikan ke
kompiler mengenai:
• Tipe data keluaran
dari fungsi.
• Jumlah parameter
yang digunakan
• Tipe data dari
masing-masing parameter yang digunakan.
Prototipe fungsi
dituliskan di atas blok program utama dan diakhiri dengan
tanda qualifier titik
koma ( ; ), sedangkan blok program fungsi yang mengandung
perintah-perintah
atau pernyataan-pernyataan dari program berada di bawah blok
program utama yang
memiliki keuntungan sebagai berikut:
• Kompiler akan
melakukan konversi antara tipe parameter dalam definisi dan
parameter fungsi.
• Jika jumlah
parameter yang digunakan dalam definisi fungsi dan pada saat
pemanggilan fungsi
berbeda atau tidak sama, maka akan menunjukkan kesalahan.
Sedangkan yang
dimaksud dengan parameter pada fungsi adalah suatu
pendefinisian
nilai-nilai dari objek-objek yang dideklarasikan pada bagian argumen
di fungsi.
Nilai-nilai pada objek-objek tersebut didapat dari variabel-variabel yang
barada pada program
utama.
Terdapat dua macam
para parameter fungsi, yaitu :
• Parameter formal
adalah variabel yang terdapat pada daftar parameter yang
berada
didalam definisi fungsi.
• Parameter Aktual
adalah variabel yang digunakan pada pemanggilan suatu
fungsi.
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 120
Bentuk penulisan
Parameter Formal dan Parameter Aktual.
Contoh penggunaan
prototipe fungsi dan parameter fungsi sebagai berikut:
Contoh-2
//Penggunaan Prototipe pada Fungsi
#include
#include
#include
//untuk strcpy
char coment (char
ket[30],int n); //prototipe fungsi
main( )
{
char lagi,c[30];
int i;
atas:
clrscr( );
{
cout<<"Masukkan
nilai = ";cin>>i;
coment(c,i);
//paramater formal
cout<
cout<<"\n\nIngin
input lagi [Y/T]: ";cin>>lagi;
}
if (lagi=='Y' ||
lagi=='y')
goto atas;
else
getch( );
}
//blok program fungsi
dengan parameter aktual
char coment (char
ket[30],int n)
{
int a;
a=n%2;
if (a==1)
strcpy(ket,"---Bilangan
Ganjil---");
else
strcpy(ket,"---Bilangan
Genap---");
}
main()
{
…..
total(a,
b);
…..
}
parameter
aktual
parameter
formal
float
total( int x, int y)
{
…...
}
Output yang akan
dihasilkan, dari program contoh-2 diatas adalah:
Gambar
9.2. Hasil Contoh-2
Di dalam bahasa C++
ada dua cara untuk melewatkan nilai-nilai parameter ke
dalam fungsi dari
nilai-nilai variabel, yaitu:
9.2.1.
Pemanggilan dengan nilai ( Call by Value )
Pada pemanggilan
dengan nilai yaitu nilai dari parameter aktual akan
dimasukkan ke
parameter formal. Dengan cara ini nilai parameter aktual tidak dapat
berubah, walaupun
nilai dari parameter formal berubah. Berikut contoh pemanggilan
dengan nilai dapat
dilihat pada contoh berikut:
Contoh-3
/* ------------------------ */
/* Penggunaan Call By
Value */
/* Program Tambah
Nilai */
/*
------------------------ */
#include
#include
#include
tambah(int m, int n);
main( )
{
int a, b;
a = 5;
b = 9;
clrscr( );
cout<<"Nilai
Sebelum Fungsi Digunakan ";
cout<<"\na
= "<tambah(a,b);
cout<<"\nNilai
Setelah Fungsi Digunakan";
cout<<"\na
= "<getch( ) ;
}
tambah(int m, int n)
{
m+=5;
n+=7;
cout<<"\n\n
Nilai di dalam Fungsi Tambah( )";
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 122
cout<<"\n
m = "<cout<
}
Output yang akan
dihasilkan, dari program contoh-3 diatas adalah :
Gambar
9.3. Hasil Contoh-3
9.2.2.
Pemanggilan dengan Referensi (Call by Reference)
Pemanggilan dengan
referensi merupakan pemanggilan nilai suatu parameter
di dalam fungsi ke
parameter actual yang disimpan pada alamat memori dengan
menggunakan pointer.
Cara ini dapat dipakai untuk mengubah isi suatu parameter
aktual dengan
melaksanakan pengubahan nilai dari suatu parameter yang dilakukan
di dalam fungsi.
Contoh-4
/* ---------------------------- */
/* Penggunaan Call By
Reference */
/* Program Tambah
Nilai */
/*
---------------------------- */
#include
#include
#include
tambah(int *c, int
*d); // deklarasi prototype fungsi
// program utama
main( )
{
int a, b;
a = 4;
b = 6;
clrscr( );
cout<<"
Nilai Sebelum Pemanggilan Fungsi";
cout<<"\n
a = "<tambah(&a,&b);
cout<
cout<<"\n
Nilai Setelah Pemanggilan Fungsi";
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 123
cout<<"\n
a = "<getch( );
}
//blok program fungsi
tambah(int *c, int
*d)
{
*c+=7;
*d+=5;
cout<
cout<<"\n
Nilai di Akhir Fungsi Tambah()";
cout<<"\n
c = "<<*c<<" d = "<<*d;
}
Output yang akan
dihasilkan, dari program contoh-4 diatas adalah:
Gambar
9.4. Hasil Contoh-4
9.3.
Pernyataan return().
Digunakan untuk
mengirimkan nilai atau nilai dari suatu fungsi kepada fungsi
yang lain yang
memanggilnya. Pernyataan return() diikuti oleh argumen yang
berupa nilai yang
akan dikirimkan. Syarat utama dalam pembuatan fungsi return
adalah nama fungsi
yang dapat mengembalikan nilai, dikarenakan nilai hasil dari
parameter formal akan
disimpan pada nama fungsi. Contoh pemakaian pernyataan
return()
dapat dilihat pada contoh berikut:
Contoh-5
/* Pernyataan Return pd Fungsi */
#include
#include
#include
float luas (int r)
//fungsi luas lingkaran
{
return(3.14*r*r); }
float kel (int r)
//fungsi kel lingkaran
{
return(3.14*2*r); }
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 124
main( )
{
int j;
clrscr( );
cout<<"Masukkan
Jari-jari = ";cin>>j;
cout<<"Luas
lingkaran = "<
cout<<"Keliling
lingkaran = "<
getch( );
}
Output yang akan
dihasilkan, dari program contoh-5 diatas adalah:
Gambar
9.5. Hasil Contoh-5
9.4.
Jenis Variabel
Jenis Variabel pada
C++ ini sangat berguna didalam penulisan suatu fungsi
agar penggunaan
didalam penggunaan suatu variabel tidak salah. Terdapat beberapa
jenis variabel yaitu:
• Variabel Lokal.
• Variabel Eksternal
atau Global.
• Variabel Statis.
9.4.1.
Variabel Lokal
Variabel Lokal adalah
variabel yang dideklarasikan didalam fungsi dan hanya
dikenal oleh fungsi
yang bersangkutan. Variabel lokal biasa disebut dengan Variabel
Otomatis.
Contoh-6
/* -------------- */
/* Variabel Lokal */
/* -------------- */
#include
#include
#include
lokal(
);
main( )
{
int a = 15;
clrscr( );
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 125
cout<<"Pemanggilan
Variabel Lokal"<
lokal(
);
getch( );
}
lokal(
)
{
int a = 10;
}
Output yang akan
dihasilkan, dari program contoh-6 diatas adalah:
Gambar
9.6. Hasil Contoh-6
9.4.2.
Variabel Eksternal
Variabel Eksternal
adalah variabel yang dideklarasikan diluar fungsi yang
bersifat global yang
artinya dapat digunakan bersama-sama tanpa harus
dideklarasikan
berulang-ulang. Untuk pendeklarasian variabel ekternal ini, diluar
dari fungsi main(),
yang selama ini pendeklarasian variabel selalu didalam fungsi
main().
Contoh-7
/* ------------------------------ */
/* Variabel Eksternal
atau Global */
/*
------------------------------ */
#include
#include
#include
int a = 6; //-->
deklarasi variabel eksternal
void lokal( );
void main( )
{
clrscr( );
cout<<"Penggunaan
Variabel Eksternal"<
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 126
lokal ( ); //-->
pemanggilan fungsi local
cout<<"\nNilai
Setelah penggilan fungsi local() = ";
getch( );
}
void lokal( )
{
a+=10;
}
Output yang akan
dihasilkan, dari program contoh-7 diatas adalah:
Gambar
9.7. Hasil Contoh-7
9.4.3.
Variabel Statis
Variabel Statis dapat
berupa variabel local atau variabel eksternal Sifat variabel
statis ini mempunyai
sifat antar lain.
• Jika variabel statis
bersifat local, maka variabel hanya dikenal oleh fungsi tempat
variabel
dideklarasikan.
• Jika variabel
statis bersifat eksternal, maka variabel dapat dipergunakan oleh
semua fungsi yang
terletak pada file yang sama ditempat variabel statis
dideklarasikan.
• Jika tidak ada
inisialisasi oleh pemrograman secara otomatis akan diberikan nilai
awal nol.
Suatu variabel statis
diperoleh dengan menambahkan kata-kunci static
didepan penentu tipe
data variabel.
Contoh-8
/* -------------------------- */
/* Penggunaan
Variabel Statis */
/*
-------------------------- */
#include
#include
#include
walah( ); //-->
prototipe fungsi walah
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 127
main( )
{
int k = 5;
clrscr( );
walah( );
walah( );
cout<<"\nNilai
K didalam fungsi main() = "<
getch( );
}
walah( )
{
static int k; //
--> deklarasi variabel statis
k += 4;
cout<<"\nNilai
K didalam fungsi() = "<
}
Output yang akan
dihasilkan, dari program contoh-8 diatas adalah :
Gambar
9.8. Hasil Contoh-8
9.5.
Fungsi inline
Fungsi inline ( inline
function ) digunakan untuk mengurangi lambatnya
eksekusi program dan
mempercepat eksekusi program terutama pada program yang
sering menggunakan
atau memanggil fungsi yang berlebih. terutama programprogram
yang menggunakan
pernyataan perulangan proses seperti for, while dan do
– while. Inline
function dideklarasikan dengan menambahkan kata kunci inline
didepan tipe data.
Hal ini terlihat
bahwa :
• Pada pada prototipe
fungsi walah( ) tidak tedapat nilai awal,
maka secara otomatis
variabel k = 0.
• Pada pemanggilan
fungsi walah( ) pertama, tercetak nilai
variabel k = 4,
didapat dari k=0+4.
• Pada pemanggilan
fungsi walah( ) kedua, tercetak nilai
variabel k = 8,
didapat dari k=4+4, karena nilai k yang
terbaru adalah 4.
• Pada pencetakan k
didalam fungsi main( ), adalah 5, karena
variabel k, didalam
fungsi main( ) bersifat lokal.
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 128
Contoh-9
/* -------------------------- */
/* Penggunaan inlide
function */
/*
-------------------------- */
#include
#include
#include
inline int kali(int
i, int j)
{
return(i * j);
}
main( )
{
int k;
clrscr( );
for(k = 1; k < 20;
k++)
cout<
getch( );
}
Output yang akan
dihasilkan, dari program contoh-9 diatas adalah:
Gambar
9.9. Hasil Contoh-9
Contoh-10
/* -------------------------- */
/* Penggunaan inlide
function */
/*
-------------------------- */
#include
#include
#include
inline static void
cplusplus( )
{
cout <<
"Pemrogramman C++\n";
cout <<
"C++ Programming, ";
}
int main( )
{
{
cout <<
"Kami Sedang Belajar, ";
cplusplus( );
cout <<
"Sedang Kami Pelajari.\n\n";
}
{
cout <<
"Mari Belajar, ";
cplusplus( );
cout <<
"Mudah Untuk Dipelajari.\n\n";
}
{
cout <<
"Jika Sudah Mengerti, ";
cplusplus( );
cout <<
"Berarti Sudah Anda Kuasai";
}
getche( );
}
Output yang akan
dihasilkan, dari program contoh-10 diatas adalah :
Gambar
9.10. Hasil Contoh-10
10.6.
Function Overloading
Function Overloading
adalah mendefinisikan beberapa fungsi, sehingga
memiliki nama yang
sama tetapi dengan parameter yang berbeda. Dapat diartikan
bahwa fungsi yang
overload berarti menyediakan versi lain dari fungsi tersebut.
Salah satu kelebihan
dari C++ adalah Overloading. s
Sebagai contoh
membentuk fungsi yang sama dengna tipe yang berbeda-beda dan
dibuatkan pula nama
fungsi yang berbeda-beda pula.
Contoh-11
/* ------------------------------- */
/* Penggunaan
function overloading */
/* -------------------------------
*/
#include
#include
#include
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi
MI 130
int hitung(int b);
long hitung(long c);
float hitung(float
d);
void main( )
{
clrscr( );
cout<<
"Hasilnya Fungsi overload -1 : ";
cout<
cout<<
"Hasilnya Fungsi overload -2 : ";
cout<
cout<<
"Hasilnya Fungsi overload -3 : ";
cout<
getch( );
}
int hitung(int b)
{
return(b*b);
}
long hitung(long c)
{
return(c*c);
}
double hitung(double
d)
{
return(d*d);
}
Output yang akan
dihasilkan, dari program contoh-11 diatas adalah :
Gambar
9.11. Hasil Contoh-11
Modul
Algoritma Pemrograman I
Tim Penyusun Komisi MI 131
0 komentar:
Posting Komentar