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
kelayar dan masih
banyak lainnya.
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<conio.h>
#include<stdio.h>
#include<iostream.h>
garis( )
{
printf("\n----------------------\n");
}
nama_fungsi(argumen)
{
…
pernyataan / perintah;
…
pernyataan / perintah;
…
pernyataan / perintah;
}
main( )
{
clrscr( );
garis( ); //memanggil
fungsi garis
cout<<"AMIK
BSI - Pondok Labu"<<endl;
garis( ); //memanggil
fungsi garis
getche( );
}
Output yang akan
dihasilkan, dari program contoh-1 diatas adalah:
Gambar
Hasil Contoh-1
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.
Bentuk penulisan
Parameter Formal dan Parameter Aktual.
Contoh penggunaan
prototipe fungsi dan parameter fungsi sebagai berikut:
Contoh-2
//Penggunaan Prototipe pada Fungsi
#include
<conio.h>
#include
<iostream.h>
#include
<string.h> //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<<c;
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)
{
…...
}
Di dalam bahasa C++
ada dua cara untuk melewatkan nilai-nilai parameter ke
dalam fungsi dari
nilai-nilai variabel, yaitu:
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
#include<stdio>
#include<iostream>
#include<conio>
judul() //fumgsijudul
{
cout<<"-------------------------------\n";
cout<<"menghitung luas persegi panjang\n";
cout<<"-------------------------------\n";
}
//fungsi perhitungan dan penambahan nilai
int luas(int x,int y)
{
int z;
x=x+2;
y=y+2;
cout<<"panjang\t :"<<x<<endl;
cout<<"lebar \t :"<<y<<endl;
return(z=x*y);
}
//fungsi pemberian komentar
char comment(char ket[30],int x,int y)
{
if(x>y)
strcpy(ket,"panjang>lebar");
else
strcpy(ket,"panjang<lebar");
}
//program utama
main()
{
char c[30];
int p,l;
judul();
cout<<"panjang\t: "; cin>>p;
cout<<"lebar \t: "; cin>>l;
comment(c,p,l);//parameter aktual
cout<<"panjang\t: "<<p<<endl;
cout<<"lebar \t: "<<l<<endl;
cout<<"luas\t :"<<luas(p,l)<<endl;
cout<<"keterangan \t :"<<c;
getch();
}
Output yang akan
dihasilkan, dari program contoh diatas adalah :
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-
/*
---------------------------- */
/* Penggunaan Call By
Reference */
/* Program Tambah
Nilai */
/*
---------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
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 = "<<a<<" b = "<<b;
tambah(&a,&b);
cout<<endl;
cout<<"\n
Nilai Setelah Pemanggilan Fungsi";
cout<<"\n
a = "<<a<<" b = "<<b;
getch( );
}
//blok program fungsi
tambah(int *c, int
*d)
{
*c+=7;
*d+=5;
cout<<endl;
cout<<"\n
Nilai di Akhir Fungsi Tambah()";
cout<<"\n
c = "<<*c<<" d = "<<*d;
}
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- /* Pernyataan Return pd Fungsi */
#include <conio.h>
#include
<iostream.h>
#include
<stdio.h>
float luas (int r)
//fungsi luas lingkaran
{
return(3.14*r*r); }
float kel (int r)
//fungsi kel lingkaran
{
return(3.14*2*r); }
main( )
{
int j;
clrscr( );
cout<<"Masukkan
Jari-jari = ";cin>>j;
cout<<"Luas
lingkaran = "<<luas(j)<<endl;
cout<<"Keliling
lingkaran = "<<kel(j);
getch( );
}
Output yang akan
dihasilkan, dari program contoh-5 diatas adalah:
Gambar
9.5. Hasil Contoh-5
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.
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-/*
-------------- */
/* Variabel Lokal */
/* -------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
lokal(
);
main( )
{
int a = 15;
clrscr( );
cout<<"Pemanggilan
Variabel Lokal"<<endl;
cout<<"\nNilai
didalam funsi main() = : "<<a;
lokal(
);
cout<<"\nNilai
didalam funsi main() = : "<<a;
getch( );
}
lokal(
)
{
int a = 10;
cout<<"\nNilai
a didalam fungsi lokal( ) = "<<a;
}
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-
/*
------------------------------ */
/* Variabel Eksternal
atau Global */
/*
------------------------------ */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
int a = 6; //--> deklarasi
variabel eksternal
void lokal( );
void main( )
{
clrscr( );
cout<<"Penggunaan
Variabel Eksternal"<<endl;
cout<<"\nNilai
didalam funsi main() = : "<<a;
lokal ( ); //-->
pemanggilan fungsi local
cout<<"\nNilai
Setelah penggilan fungsi local() = ";
cout<<a;
getch( );
}
void lokal( )
{
a+=10;
}
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-
/*
-------------------------- */
/* Penggunaan
Variabel Statis */
/*
-------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
walah( ); //-->
prototipe fungsi walah
main( )
{
int k = 5;
clrscr( );
walah( );
walah( );
cout<<"\nNilai
K didalam fungsi main() = "<<k;
getch( );
}
walah( )
{
static int k; //
--> deklarasi variabel statis
k += 4;
cout<<"\nNilai
K didalam fungsi() = "<<k;
}
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
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.
Contoh-
/* -------------------------- */
/* Penggunaan inlide function */
/* -------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
inline int kali(int i, int j)
{
return(i * j);
}
main( )
{
int k;
clrscr( );
for(k = 1; k < 20; k++)
cout<<kali(k,
k*2)<<" ";
getch( );
}
Output yang akan dihasilkan, dari
program contoh-9 diatas adalah:
Gambar
Contoh-
/* -------------------------- */
/* Penggunaan inlide function */
/* -------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
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( );
}
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
/*
------------------------------- */
/* Penggunaan function
overloading */
/*
------------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream.h>
int hitung(int b);
long hitung(long c);
float hitung(float d);
void main( )
{
clrscr( );
cout<< "Hasilnya
Fungsi overload -1 : ";
cout<<hitung(4)<<endl;
cout<< "Hasilnya
Fungsi overload -2 : ";
cout<<hitung(2)<<endl;
cout<< "Hasilnya
Fungsi overload -3 : ";
cout<<hitung(3)<<endl;
getch( );
}
int hitung(int b)
{
return(b*b);
}
long hitung(long c)
{
return(c*c);
}
double hitung(double d)
{
return(d*d);
}
0 komentar:
Posting Komentar