Lingkup Variabel
Pada C++, kita dapat mendeklarasikan
variable dibagian mana saja dari program, bahkan diantara 2 kalimat perintah.
variabel Global dapat digunakan untuk
setiap bagian dari program, maupun fungsi, walaupun dideklarasikan diakhir
program.
Lingkup dari variable local terbatas. Hanya
berlaku dimana variable tersebut dideklarasikan. Jika dideklarasikan diawal
fungsi (seperti dalam main) maka lingkup dari variable tersebut adalah untuk
seluruh fungsi main. Seperti contoh diatas, jika terdapat fungsi lain yang
ditambahkan pada main(), maka variable
local yang dideklarasikan dalam main tidak dapat digunakan pada fungsi lainnya
dan sebaliknya.
Pada C++, lingkup variable local ditandai
dengan blok dimana variable tersebut dideklarasikan ( blok tersebut adalah
sekumpulan instruksi dalam kurung kurawal {} ). Jika dideklarasikan dalam
fungsi tersebut, maka akan berlaku sebagai variable dalam fungsi tersebut, jika
dideklarasikan dalam sebuah perulangan, maka hanya berlaku dalam perulangan
tersebut, dan seterusnya.
ARGUMEN FUNGSI
Dalam C++, argumen-argumen dari fungsi
dapat mempunyai harga default. Jika pada saat fungsi yang mempunyai default
argumen ini dipanggil namun argumennya dihilangkan maka kompiler otomatis akan
memakai nilai default dari argumen yang dihilangkan tersebut. Jika pada saat
dipanggil argumennya diisi maka isi ini yang dipakai. Default argumen ini
membuat program menjadi lebih fleksibel, argumen-argumen yang nilai defaultnya
tidak perlu diubah tidak perlu diisi namun ada aturan yang perlu diperhatikan.
Bila kita menghilangkan argumen yang
pertama maka argumen-argumen selanjutnya juga harus dihilangkan. Kita dapat
menghilangkan argumen yang kedua dan mengisi argumen yang pertama. Aturan ini
tidak terikat padajumlah argumen. Secara umum aturannya adalah kalau kita menghilangkan suatu argumen
maka kita harus menghilangkan semua argumen dikanannya.
Perhatikan bahwa untuk memanggil fungsi
cukup dengan menulis namanya, termasuk tanda kurung dan argumen-argumennya dan
diakhiri dengan titik koma (;).
Inline Function
Inline function dengan cukup menyisipkan kata-kata 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 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;
jika fungsi jumlah () tidak ditulis sebagai inline function, proses tersebut
akan menjadi relatif lambat.
Contoh :
Contoh program :
//*---------------------------------------------------------*
//* Contoh 5.11 : Pembuatan fungsi inline *
//*---------------------------------------------------------*
#include <iostream.h>
#include <conio.h>
// Definisi fungsi sebagai inline
inline int jumlah(int x, int y)
{
return(x + y );
}
void main()
{
clrscr();
for (int i = 1; i < 100; i ++ )
cout << i << “ . “ << jumlah(i, 2 * i) << endl;
}
Nilai Bawaan Untuk Nilai Fungsi
Salah satu keistimewaan C++ adalah adanya kemampuan untuk menyetel nilai bawaan
(default) argumen fungsi. Argumen-argumen yang mempunyai nilai bawaan nantinya
dapat tidak disertakan didalam pemanggilan fungsi dan dengan sendirinya C++
akan menggunakan nilai bawaan dari argumen yang tidak disertakan.
Contoh program :
//*--------------------------------------------------------------*
//* Contoh 5.7 : Menggambarkan nilai bawaan dalam *
//* argumen fungsi *
//*--------------------------------------------------------------*
#include <iostream.h>
#include <conio.h>
void tulis_cplus(int jum); // Prototipe fungsi
void main()
{
clrscr();
tulis_cplus(1); // Untuk menuliskan sebuah tulisan C++
}
void tulis_cplus(int jum);
{
for (int i = 0; i < jum; i ++)
cout << “ C++ “ << endl;
cout << “ Seleseai “ << endl;
}
Function Overloading
Function Overloading atau Overloading terhadap fungsi memungkinkan sebuah
fungsi dapat menerima bermacam-macam tipe dan memberikan nilai balik yang
bervariasi pula.
Contoh program :
//*-----------------------------------------------*
//* Contoh 5.12 : Contoh overloading *
//* terhadap fungsi *
//*-----------------------------------------------*
#include <iostream.h>
#include <conio.h>
// Prototipe fungsi
int kuadrat (int i);
long kuadrat(long l);
double kuadrat(double d);
void main()
{
cout << kuadrat(2) << endl;
cout << kuadrat(66666) << endl;
cout << kuadrat(1.2) << endl;
}
// Definisi fungsi
int kuadrat (int i)
{
return(i * i);
}
long kuadrat (long l)
{
return(l * l);
}
double kuadrat (double d)
{
return(d * d);
}
Rekursi
Fungsi dalam C++ dapat dipakai secara rekursi, artinya suatu fungsi dapat
memanggil fungsi yang merupakan dirinya sendiri. Penerapan rekursi diantaranya
untuk menghitung nilai :
Xn
Dengan n merupakan bilangan bulat positif. Solusi dari persoalan ini berupa
:
Jika n = 1 maka Xn = X
Selain itu : Xn = X * Xn – 1
Contoh program :
//*------------------------------------------------*
//* Contoh 5.13 : Opreasi pangkat secara *
//* rekursi *
//*------------------------------------------------*
# include <iostream.h>
#include <conio.h>
long int pangkat ( int x, int n);
void main()
{
int x, y;
clrscr();
cout << “ Menghitung x ^ y “<< endl;
cout << “ x = “ ;
cin >> x ;
cout << “ y = “ ;
cin >> y ;
cout << x << “ ^ “ << y << endl;
<< pangkat(x, y) << endl;
}
long int pangkat(int x, int n)
{
if (n = = 1 )
return(x);
else
return(x * pangkat(x, n – 1));
}