Fungsi

Fungsi memungkinkan untuk menyusun program dalam segmen kode untuk melakukan tugas
individual.

Dalam C++, sebuah fungsi adalah sekelompok pernyataan yang diberi nama, dan yang dapat
dipanggil dari beberapa titik program. Sintaks yang paling umum untuk mendefinisikan suatu fungsi
adalah: Di mana: - adalah tipe nilai yang dikembalikan oleh fungsi. - adalah pengidentifikasi yang
dengannya fungsi dapat dipanggil. - (sebanyak yang dibutuhkan): Setiap parameter terdiri dari
sebuah tipe yang diikuti oleh pengenal, dengan setiap parameter dipisahkan dari yang berikutnya
dengan koma. Setiap parameter sangat mirip dengan deklarasi variabel biasa (misalnya:

type name ( parameter1, parameter2, ...) { statements }

type
name
parametersint x), dan sebenarnya bertindak di dalam fungsi sebagai variabel reguler yang bersifat
lokal untuk fungsi tersebut. Tujuan dari parameter adalah untuk memungkinkan melewati argumen
ke fungsi dari lokasi dari mana ia dipanggil.
- statementsadalah tubuh fungsi. Ini adalah blok pernyataan yang dikelilingi oleh kurung kurawal {}
yang menentukan fungsi yang sebenarnya.

Mari kita lihat sebuah contoh:

// function example
#include <iostream>
using namespace std;

int addition (int a, int b)

{
int r;
r=a+b;
return r;
}

int main ()
{
int z;
z = addition (5,3);
cout << "The result is " << z;
}
Hasilnya adalah 8
Edit & jalankan di cpp.sh

Program ini dibagi dalam dua fungsi: additiondan main. Ingatlah bahwa tidak peduli urutan
definisinya, program C++ selalu dimulai dengan memanggil main. Faktanya, mainini adalah satu-
satunya fungsi yang dipanggil secara otomatis, dan kode di fungsi lainnya hanya dijalankan jika
fungsinya dipanggil dari main(langsung atau tidak langsung).

Pada contoh di atas, maindimulai dengan mendeklarasikan variabel ztype int, dan tepat setelah itu,
ia melakukan pemanggilan fungsi pertama: ia memanggil addition. Panggilan ke suatu fungsi
mengikuti struktur yang sangat mirip dengan deklarasinya. Pada contoh di atas, panggilan ke
additiondapat dibandingkan dengan definisinya beberapa baris sebelumnya:

Parameter dalam deklarasi fungsi memiliki korespondensi yang jelas dengan argumen yang
diteruskan dalam pemanggilan fungsi. Panggilan melewati dua nilai, 5dan 3, ke fungsi; ini sesuai
dengan parameter adan b, dideklarasikan untuk function addition.

Pada titik di mana fungsi dipanggil dari dalam main, kontrol diteruskan ke function addition: di sini,
eksekusi maindihentikan, dan hanya akan dilanjutkan setelah additionfungsi berakhir. Pada saat
pemanggilan fungsi, nilai dari kedua argumen ( 5dan 3) disalin ke variabel lokal int adan int bdi
dalam fungsi.

Kemudian, di dalam addition, variabel lokal lain dideklarasikan ( int r), dan melalui ekspresir=a+b,
hasil aplus bditugaskan untuk r; yang, untuk kasus ini, dimana aadalah 5 dan b3, berarti bahwa 8
ditugaskan ke r.

Pernyataan terakhir dalam fungsi:

1
return r;

Mengakhiri function addition, dan mengembalikan kontrol ke titik di mana fungsi dipanggil; dalam
hal ini: berfungsi main. Pada saat yang tepat ini, program melanjutkan programnya untuk
mainkembali tepat pada titik yang sama di mana ia diinterupsi oleh panggilan ke addition. Tetapi
selain itu, karena additionmemiliki tipe pengembalian, panggilan tersebut dinilai memiliki nilai, dan
nilai ini adalah nilai yang ditentukan dalam pernyataan pengembalian yang berakhir addition: dalam
kasus khusus ini, nilai variabel lokal r, yang pada saat returnpernyataan memiliki nilai 8.

Oleh karena itu, pemanggilan ke additionadalah ekspresi dengan nilai yang dikembalikan oleh fungsi,
dan dalam hal ini, nilai itu, 8, ditugaskan kez. Seolah-olah seluruh pemanggilan fungsi ( addition(5,3))
diganti dengan nilai yang dikembalikannya (yaitu, 8).

Kemudian main cukup mencetak nilai ini dengan memanggil:

1
cout << "The result is " << z;

Suatu fungsi sebenarnya dapat dipanggil beberapa kali dalam suatu program, dan argumennya
secara alami tidak terbatas hanya pada literal:
// function example
#include <iostream>
using namespace std;

int subtraction (int a, int b)

{
int r;
r=a-b;
return r;
}

int main ()
{
int x=5, y=3, z;
z = subtraction (7,2);
cout << "The first result is " << z << '\n';
cout << "The second result is " << subtraction (7,2) << '\n';
cout << "The third result is " << subtraction (x,y) << '\n';
z= 4 + subtraction (x,y);
cout << "The fourth result is " << z << '\n';
}
Hasil pertama adalah 5
Hasil kedua adalah 5
Hasil ketiga adalah 2
Hasil keempat adalah 6
Edit & jalankan di cpp.sh

Mirip dengan additionfungsi pada contoh sebelumnya, contoh ini mendefinisikan sebuah
subtractfungsi, yang hanya mengembalikan selisih antara dua parameternya. Kali ini, mainpanggil
fungsi ini beberapa kali, mendemonstrasikan lebih banyak cara yang memungkinkan untuk
memanggil fungsi.

Mari kita periksa masing-masing pemanggilan ini, dengan mengingat bahwa setiap pemanggilan
fungsi itu sendiri merupakan ekspresi yang dievaluasi sebagai nilai yang dikembalikannya. Sekali
lagi, Anda dapat menganggapnya seolah-olah pemanggilan fungsi itu sendiri digantikan oleh nilai
yang dikembalikan:

1
2
z = subtraction (7,2);
cout << "The first result is " << z;

Jika kita mengganti pemanggilan fungsi dengan nilai yang dikembalikannya (yaitu, 5), kita akan
mendapatkan:
1
2
z = 5;
cout << "The first result is " << z;

Dengan prosedur yang sama, kita dapat menginterpretasikan:

1
cout << "The second result is " << subtraction (7,2);

sebagai:
1
cout << "The second result is " << 5;

karena 5 adalah nilai yang dikembalikan oleh subtraction (7,2).

Dalam kasus:

1
cout << "The third result is " << subtraction (x,y);

Argumen yang diteruskan ke pengurangan adalah variabel, bukan literal. Itu juga valid, dan berfungsi
dengan baik. Fungsi dipanggil dengan nilai xdan ypada saat pemanggilan: masing-masing 5 dan 3,
mengembalikan 2 sebagai hasilnya.

Panggilan keempat sekali lagi serupa:

1
z = 4 + subtraction (x,y);

Satu-satunya tambahan adalah bahwa sekarang pemanggilan fungsi juga merupakan operan dari
operasi penjumlahan. Sekali lagi, hasilnya sama seperti jika pemanggilan fungsi diganti dengan
hasilnya: 6. Perhatikan, bahwa berkat sifat komutatif dari penjumlahan, hal di atas juga dapat ditulis
sebagai:

1
z = subtraction (x,y) + 4;
mungkin tidak perlu mengembalikan nilai apa pun:

type name ( argument1, argument2 ...) { statements }

void

// void function example

#include <iostream>
using namespace std;
void printmessage ()
{
cout << "I'm a function!";
}

int main ()
{
printmessage ();
}
Aku fungsi!
Edit & jalankan di cpp.sh

voidjuga dapat digunakan dalam daftar parameter fungsi untuk menentukan secara eksplisit bahwa
fungsi tidak mengambil parameter aktual saat dipanggil. Misalnya, printmessagedapat dinyatakan
sebagai:

1
2
3
4
void printmessage (void)
{
cout << "I'm a function!";
}

Dalam C++, daftar parameter kosong dapat digunakan alih-alih voiddengan arti yang sama, tetapi
penggunaan voiddalam daftar argumen dipopulerkan oleh bahasa C, di mana ini merupakan
persyaratan.

Sesuatu yang sama sekali tidak opsional adalah tanda kurung yang mengikuti nama fungsi, baik
dalam deklarasi maupun saat memanggilnya. Dan bahkan ketika fungsi tidak mengambil parameter,
setidaknya sepasang tanda kurung kosong harus selalu ditambahkan ke nama fungsi. Lihat
bagaimana printmessagedipanggil dalam contoh sebelumnya:

1
printmessage ();

Tanda kurung adalah yang membedakan fungsi dari jenis deklarasi atau pernyataan lainnya. Berikut
ini tidak akan memanggil fungsi:

1
printmessage;

Dalam hal ini, penjumlahan fungsi dilewatkan 5 dan 3, yang masing-masing merupakan salinan dari
nilai xdan y. Nilai-nilai ini (5 dan 3) digunakan untuk menginisialisasi variabel yang ditetapkan
sebagai parameter dalam definisi fungsi, tetapi setiap modifikasi variabel ini di dalam fungsi tidak
berpengaruh pada nilai variabel x dan y di luarnya, karena x dan y adalah sendiri tidak diteruskan ke
fungsi pada panggilan, tetapi hanya salinan dari nilainya pada saat itu.

Namun, dalam kasus tertentu, mungkin berguna untuk mengakses variabel eksternal dari dalam
suatu fungsi. Untuk melakukannya, argumen dapat diteruskan dengan reference , alih-alih dengan
value . Misalnya fungsiduplicatedalam kode ini menduplikasi nilai dari tiga argumennya,
menyebabkan variabel yang digunakan sebagai argumen untuk benar-benar dimodifikasi oleh
panggilan:

// passing parameters by reference

#include <iostream>
using namespace std;

void duplicate (int& a, int& b, int& c)

{
a*=2;
b*=2;
c*=2;
}

int main ()
{
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}
x=2, y=6, z=14
Edit & jalankan di cpp.sh

Untuk mendapatkan akses ke argumennya, fungsi tersebut mendeklarasikan parameternya sebagai

references . Dalam C++, referensi ditunjukkan dengan ampersand ( &) mengikuti tipe parameter,
seperti pada parameter yang diambil duplicatepada contoh di atas.

referensinya tidak akan diubah oleh fungsi ini. Ini dapat dilakukan dengan mengkualifikasikan
parameter sebagai konstanta:

1
2
3
4
string concatenate (const string& a, const string& b)
{
return a+b;
}

Dengan mengkualifikasikannya sebagai const, fungsi dilarang untuk memodifikasi nilai dari not
amaupun b, tetapi sebenarnya dapat mengakses nilainya sebagai referensi (alias dari argumen),
tanpa harus membuat salinan sebenarnya dari string.

Oleh karena itu, constreferensi menyediakan fungsionalitas yang mirip dengan meneruskan
argumen berdasarkan nilai, tetapi dengan peningkatan efisiensi untuk parameter tipe besar. Itulah
mengapa mereka sangat populer di C++ untuk argumen tipe majemuk. Perhatikan juga, bahwa untuk
sebagian besar tipe fundamental, tidak ada perbedaan efisiensi yang mencolok, dan dalam beberapa
kasus, referensi const bahkan mungkin kurang efisien!

Fungsi sebaris
Memanggil fungsi umumnya menyebabkan overhead tertentu (menumpuk argumen, melompat,
dll...), dan dengan demikian untuk fungsi yang sangat singkat, mungkin lebih efisien untuk hanya
menyisipkan kode fungsi di mana ia dipanggil, daripada melakukan proses secara formal memanggil
fungsi.

tetapi mengganti isi fungsi (blok pernyataan) dengan titik koma akhir.

Daftar parameter tidak perlu menyertakan nama parameter, tetapi hanya tipenya saja. Namun
demikian, nama parameter dapat ditentukan, tetapi bersifat opsional, dan tidak perlu harus sama
dengan yang ada di definisi fungsi. Misalnya, sebuah fungsi yang dipanggil protofunctiondengan dua
parameter int dapat dideklarasikan dengan salah satu dari pernyataan berikut:

1
2
int protofunction (int first, int second);
int protofunction (int, int);

Pokoknya, memasukkan nama untuk setiap parameter selalu meningkatkan keterbacaan deklarasi.

// declaring functions prototypes

#include <iostream>
using namespace std;

void odd (int x);

void even (int x);

int main()
{
int i;
do {
cout << "Please, enter number (0 to exit): ";
cin >> i;
odd (i);
 } while (i!=0);
return 0;
}

void odd (int x)

{
if ((x%2)!=0) cout << "It is odd.\n";
else even (x);
}

void even (int x)

{
if ((x%2)==0) cout << "It is even.\n";
else odd (x);
}
Silakan masukkan angka (0 untuk keluar): 9
Ini aneh.
Silakan masukkan angka (0 untuk keluar): 6
Hal ini bahkan.
Harap masukkan angka (0 untuk keluar): 1030
Hal ini bahkan.
Harap masukkan angka (0 untuk keluar): 0
Hal ini bahkan.
Edit & jalankan di cpp.sh

urutan fungsi di dalam kode. Dalam beberapa kasus, seperti dalam kasus khusus ini, setidaknya
satu deklarasi diperlukan, karena odddan evensaling dipanggil; ada panggilan evenmasuk odddan
panggilan oddmasukeven. Dan, oleh karena itu, tidak ada cara untuk menyusun kode sehingga
odddidefinisikan sebelum even, dan evensebelum odd.

Rekursif
Rekursif adalah properti yang fungsinya harus dipanggil sendiri. Ini berguna untuk beberapa tugas,
seperti menyortir elemen, atau menghitung faktorial angka. Misalnya, untuk mendapatkan faktorial
dari angka ( n!) rumus matematikanya adalah:

n! = n * (n-1) * (n-2) * (n-3) ... * 1

Lebih konkretnya, 5!(faktorial dari 5) adalah:

5! = 5 * 4 * 3 * 2 * 1 = 120
Dan fungsi rekursif untuk menghitung ini di C++ bisa jadi:

// factorial calculator
#include <iostream>
using namespace std;

long factorial (long a)

{
if (a > 1)
return (a * factorial (a-1));
else
return 1;
}

int main ()
{
long number = 9;
cout << number << "! = " << factorial (number);
return 0;
}
9! = 362880
Edit & jalankan di cpp.sh

Perhatikan bagaimana dalam fungsi faktorial kami menyertakan panggilan ke dirinya sendiri, tetapi
hanya jika argumen yang diteruskan lebih besar dari 1, karena, jika tidak, fungsi tersebut akan
melakukan loop rekursif tak terbatas, di mana setelah mencapai 0, ia akan terus mengalikan semua
angka negatif (mungkin memprovokasi stack overflow di beberapa titik selama runtime).