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 kelayar
dan masih banyak lainnya.
9.1. Struktur Fungsi
Penjelasan : Sebuah fungsi sederhana mempunyai bentuk penulisan sebagai berikut
:
nama_fungsi(argumen)
{
… pernyataan / perintah;
… pernyataan / perintah;
… pernyataan / perintah;
}
Keterangan:
a.
Nama fungsi, boleh dituliskan secara bebas dengan ketentuan, tidak
menggunakan
spasi dan nama-nama fungsi yang mempunyai arti sendiri.
b.
Argumen, diletakan diantara tanda kurung “( )” yang terletak
dibelakang nama fungsi. Argumen boleh diisi dengan suatu data atau dibiarkan
kosong.
c.
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>
#include<stdlib.h>
using namespace std;
garis()
{
printf("\n----------------------\n");
}
/* program utama */
main()
{
system("cls");
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 9.1.
Hasil Contoh-1
9.2. Prototipe Fungsi
Penjelasan : Prototipe fungsi digunakan untuk mendeklarasikan ke kompiler
mengenai:
a.
Tipe data keluaran dari fungsi.
b.
Jumlah parameter yang digunakan
c.
Tipe data dari masing-masing parameter yang digunakan.
Keuntungan didalam pemakai prototipe yaitu :
a.
Kompiler akan melakukan konversi antara tipe parameter dalam
definisi dan
parameter fungsi.
b.
Jika jumlah parameter yang digunakan dalam definisi fungsi dan
pada saat pemanggilan fungsi berbeda atau tidak sama, maka akan menunjukkan kesalahan.
Contoh
prototipe fungsi :
Bentuk definisi dalam penggunaan
fungsi yang dideklarasikan dengan menggunakan prototipe, harus diubah. Sebagai contoh pada pendefinisian
berikut :
float total(a, b)
float a, b;
Bentuk pendefinisian diatas harus
diubah menjadi bentuk modern pendefinisian fungsi :
9.3. Parameter Fungsi
Penjelasan : Terdapat dua macam para parameter fungsi, yaitu :
a. Parameter formal adalah variabel yang terdapat pada daftar parameter
yang berada didalam definisi fungsi.
b.
Parameter Aktual adalah variabel yang digunakan pada
pemanggilan suatu fungsi.
Bentuk penulisan Parameter Formal
dan Parameter Aktual.
Ada dua cara untuk melewatkan
parameter ke dalam fungsi, yaitu berupa :
9.3.1. Pemanggilan
dengan nilai ( Call by Value )
Penjelasan
: Pada pemanggilan dengan nilai yaitu nilai dari
parameter aktual akan dimasukkan keparameter formal. Dengan cara ini nilai
parameter aktual tidak bisa berubah, walaupun nilai dari parameter formal
berubah. Berikut contoh pemanggilan dengan nilai dapat dilihat pada contoh
berikut ;
Contoh-2 /*
------------------------ */
/* Penggunaan
Call By Value */
/* Program
Tambah Nilai */
/*
------------------------ */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using
namespace std;
int tambah(int
m, int n);
main()
{
int a, b;
a = 5;
b = 9;
system("cls");
cout<<"Nilai
Sebelum Fungsi Digunakan ";
cout<<"\na
= "<<a<<" b = "<<b;
tambah(a,b);
cout<<"\nNilai
Setelah Fungsi Digunakan";
cout<<"\na
= "<<a<<" b = "<<b;
getch();
}
tambah(int m,
int n)
{
m+=5;
n+=7;
cout<<"\n\nNilai di dalam Fungsi Tambah()";
cout<<"\nm = "<<m<<" n =
"<<n;
cout<<endl;
}
Gambar 9.2. Hasil Contoh-2
9.3.2. Pemanggilan dengan Referensi (Call by Reference)
Penjelasan
: Pemanggilan dengan
reference merupakan pemanggilan alamat suatu variabel didalam fungsi. Cara ini
dapat dipakai untuk mengubah isi suatu variabel yang diluar dari fungsi dengan
melaksanakan pengubahan nilai dari suatu variabel dilakukan didalam fungsi.
Contoh-3
/* ---------------------------- */
/* Penggunaan Call By Reference */
/* Program Tambah Nilai */
/* ---------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
int tambah(int *c, int *d);
main()
{
int a, b;
a = 4;
b = 6;
system("cls");
cout<<"Nilai Sebelum Pemanggilan Fungsi";
cout<<"\na = "<<a<<" b =
"<<b;
tambah(&a,&b);
cout<<endl;
cout<<"\nNilai Setelah Pemanggilan Fungsi";
cout<<"\na = "<<a<<" b =
"<<b;
getch();
}
tambah(int *c, int *d)
{
*c+=7;
*d+=5;
cout<<endl;
cout<<"\nNilai di Akhir Fungsi Tambah()";
cout<<"\nc = "<<*c<<" d =
"<<*d;
}
Output
yang akan dihasilkan, dari program contoh-3 diatas adalah :
Gambar
9.3. Hasil Contoh-3
9.4. Pernyataan return().
Penjelasan
: 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. Contoh
pemakaian pernyataan return() dapat dilihat pada contoh berikut ;
Contoh-4 /* -------------------------- */
/* Penggunaan Fungsi return() */
/* -------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
Int tambah(int *c); //prototype fungsi tambah
main()
{
int a, b = 5;
system(“cls”);
a = tambah(&b);
cout<<"Nilai Setelah Pemanggilan Fungsi
adalah "<<a;
getch();
}
tambah(int *c) //fungsi tambah
{
return(*c+=2);
}
Output yang akan dihasilkan, dari
program contoh-4 diatas adalah :
Gambar 9.4. Hasil Contoh-4
9.5. Pengiriman Data Ke Fungsi
9.5.1. Pengiriman Data Konstanta Ke Fungsi.
Penjelasan : Mengirimkan
suatu nilai data konstanta ke suatu fungsi yang lain dapat dilakukan dengan
cara yang mudah, dapat dilihat dari program berikut :
Contoh-5 /* ------------------------ */
/* Pengriman data Konstanta */
/* ------------------------ */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std:
int luas(float sisi);
main()
{
float luas_bs;
system (“cls”);
luas_bs = luas(4.25);
cout<<"\nLuas Bujur Sangkar = "<<luas_bs;
getch();
}
luas(float sisi)
{
return(sisi*sisi);
}
Keterangan :
Dalam struktur program diatas dilihat bahwa, pernyataan luas_bs=luas(4.25),
akan dikirimkan nilai kepada fungsi luas(), untuk diolah lebih
lanjut, yang nilai tersebut akan ditampung pada variabel sisi.
Selanjutnya didalam fungsi return terjadi perkalian sisi dengan sisi, setelah
itu hasil perkalian tersebut dikirim balik ke variabel luas_bs yang
memanggil fungsi.
Output
yang akan dihasilkan, dari program contoh-5 diatas adalah :
Gambar
9.5. Hasil Contoh-5
9.5.2. Pengiriman Data Variabel Ke Fungsi
Penjelasan
:Bentuk
pengiriman data Variabel, sama seperti halnya pengiriman suatu nilai data
konstanta ke suatu fungsi, hanya saja nilai yang dikirimkan tersebut senantiasa
dapat berubah-ubah. Bentuk pengiriman tersebut dapat dilihat dari program
berikut :
Contoh-6 /*
------------------------ */
/* Pengriman data Variabel */
/* ------------------------ */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
int luas(float sisi);
main()
{
float luas_bs, sisi_bs;
system(“cls”);
cout<<"\nMenghitung Luas
Bujur Sangkar"<<endl;
cout<<"\nMasukan Nilai Sisi
Bujur Sangkar : ";
cin>>sisi_bs;
luas_bs = luas(sisi_bs);
cout<<"\nLuas Bujur Sangkar =
"<<luas_bs<<" Cm";
getch();
}
luas(float sisi)
{
return(sisi*sisi);
}
Output yang akan dihasilkan, dari
program contoh-6 diatas adalah :
Gambar 9.6. Hasil Contoh-6
9.6. Jenis Variabel
Penjelasan :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.6.1. Variabel Lokal
Penjelasan :Variabel Lokal adalah variabel yang dideklarasikan didalam fungsi
dan hanya
dikenal oleh fungsi yang bersangkutan.
Variabel lokal biasa disebut dengan Variabel Otomatis.
Contoh-7 /*
-------------- */
/* Variabel Lokal */
/* -------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
int lokal();
main()
{
int a = 15;
system(“cls”);
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;
}
Hal
ini terlihat bahwa variabel a yang berada diluar fungsi local tidak
dikenal oleh fungsi local.
Output yang akan
dihasilkan, dari program contoh-7 diatas adalah :
Gambar
9.7. Hasil Contoh-7
9.6.2. Variabel
Eksternal
Penjelasan :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-8 /*
------------------------------ */
/* Variabel Eksternal atau Global */
/* ------------------------------ */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
int a = 6; //--> deklarasi variabel
eksternal
void lokal();
void main()
{
system(“cls”);
cout<<"Penggunaan Variabel Eksternal"<<endl;
cout<<"\nNilai didalam fungsi main() = :
"<<a;
lokal(); //--> pemanggilan fungsi local
cout<<"\nNilai Setelah penggilan fungsi local() =
";
cout<<a;
getch();
}
void lokal()
{
a+=10;
}
Hal ini terlihat bahwa variabel a yang dideklarasikan
diluar fungsi main(), dapat digunakan didalam
fungsi main() dan fungsi local().
Output yang akan dihasilkan, dari
program contoh-8 diatas adalah :
Gambar
9.8. Hasil Contoh-8
9.6.3. Variabel
Statis
Penjelasan :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-9 /*
-------------------------- */
/* Penggunaan Variabel Statis */
/* -------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
int walah(); //--> prototipe
fungsi walah
main()
{
int k = 5;
system(“cls”);
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;
}
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.
Output yang akan dihasilkan, dari program contoh-9 diatas adalah :
Gambar 9.9. Hasil
Contoh-9
9.7. Fungsi inline
Penjelasan
: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 program-program yang menggunakan
pernyataan perulangan proses seperti for,
while dan do – while. Inline function dideklarasikan dengan menambahkan
kata kunci inline didepan tipe data.
Contoh-10 /*
-------------------------- */
/* Penggunaan inlide function */
/* -------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using
namespace std;
inline int kali(int i, int j)
{
return(i * j);
}
main()
{
int k;
system(“cls”);
for(k = 1; k < 20; k++)
cout<<kali(k, k*2)<<"
";
getch();
}
Output yang akan
dihasilkan, dari program contoh-10 diatas adalah :
Gambar
9.10. Hasil Contoh-10
Contoh-11 /*
-------------------------- */
/* Penggunaan inlide function */
/*
-------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
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-11 diatas adalah
:
Gambar
9.11. Hasil Contoh-11
9.8. Function
Overloading
Penjelasan :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.
Sebagai contoh membentuk fungsi
yang sama dengna tipe yang berbeda-beda dan dibuatkan pula nama fungsi yang
berbeda-beda pula.
Contoh-12 /*
------------------------------- */
/* Penggunaan function overloading */
/* ------------------------------- */
#include<conio.h>
#include<stdio.h>
#include<iostream>
#include<stdlib.h>
using namespace std;
int hitung(int b);
long hitung(long c);
float hitung(float d);
void main()
{
system(“cls”);
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);
}
Output yang akan
dihasilkan, dari program contoh-12 diatas adalah :
Gambar 8.12. Hasil Contoh-12
DAFTAR
PUSTAKA
Frieyadie.
2006. Panduan Pemrogramman C++. [On
Line]. Tersedia: www.unlock-pdf.com_Buku C++ (utama).pdf. [10 Desember 2018]
Tidak ada komentar:
Posting Komentar