Pemrograman C++

BAB V
FUNGSI

Tujuan dari bab ini adalah agar mahasiswa :

 Bisa mengimplementasikan fungsi
 Menjadi terbiasa dengan konsep parameter passing
 Menghargai pentingnya fungsi komentar
 Mengembangkan strategi untuk mendekomposisi tugas kompleks menjadi pekerjaan yang
lebih sederhana
 Dapat menentukan ruang lingkup suatu variabel
 Mengenali kapan harus menggunakan parameter nilai dan referensi

5.1. Fungsi Sebagai Kotak Hitam (Black boxs)

Fungsi adalah urutan instruksi dengan sebuah nama. Kita telah menemukan beberapa
fungsi. Sebagai contoh, fungsi yang diberi nama pow, yang diperkenalkan pada Bab 2, berisi
instruksi untuk memanggil pangkat xy. Apalagi setiap program C++ memiliki fungsi yang
disebut main.
Anda memanggil fungsi untuk menjalankan instruksinya. Misalnya, perhatikan program
berikut ini:
int main ()
{
double z = pow (2, 3);
...
}

Dengan menggunakan pow ekspresi (2, 3), main memanggil fungsi pow, memintanya
untuk menghitung pangkat 23. Fungsi main untuk sementara ditangguhkan. Instruksi dari fungsi
pow mengeksekusi dan menghitung hasilnya. Fungsi pow mengembalikan hasilnya (yaitu, nilai
8) kembali ke main, dan fungsi main melanjutkan eksekusi (lihat Gambar 5.1).

sebuah fungsi adalah urutan instruksi yang dinamai.

Fungsi-129
 Pemrograman C++

Gambar 5.1. Aliran Eksekusi Selama Memanggil Fungsi

Ketika fungsi lain memanggil fungsi pow, ia menyediakan "input", seperti ekspresi 2 dan
3 pada pow (2, 3). Ungkapan ini disebut argumen. Terminologi ini menghindari kebingungan
dengan input lain, seperti yang dipandu oleh pengguna manusia. Demikian pula, "output" yang
dihitung fungsi pow disebut nilai pengembalian (return value). Fungsi dapat memiliki banyak
argumen, namun hanya memiliki satu nilai pengembalian. Perhatikan bahwa nilai pengembalian
suatu fungsi dikembalikan ke fungsi pemanggil, tidak ditampilkan di layar. Misalnya, program
Anda berisi pernyataan:
double z = pow(2, 3);

Argumen dipasok saat sebuah fungsi dipanggil. nilai kembalian adalah hasil
yang dihitung fungsi.

Ketika fungsi pow mengembalikan hasilnya, nilai kembalian disimpan dalam variabel z.
Jika kita ingin nilai ditampilkan, Anda perlu menambahkan pernyataan seperti cout << z.

Fungsi-130
 Pemrograman C++

Pada titik ini, kita mungkin bertanya-tanya bagaimana fungsi pow melakukan tugasnya.
Sebagai contoh, bagaimana pow (2, 3) menghitung bahwa 23 adalah 8? Dengan mengalikan 2 × 2
× 2? Dengan logaritma? Untungnya, sebagai pengguna fungsi, kita tidak perlu tahu bagaimana
fungsi diimplementasikan. Kita hanya perlu mengetahui spesifikasi fungsinya: Jika kita
memberikan argumen x dan y, fungsi mengembalikan xy. Insinyur menggunakan istilah kotak
hitam (black boxes) untuk perangkat dengan spesifikasi tertentu namun tidak diketahui
implementasinya. Kita bisa menganggap pow sebagai kotak hitam, seperti yang ditunjukkan
pada Gambar 5.2.

Gambar 5.2. Fungsi pow sebagai Black Box

Bila kita merancang fungsi kita sendiri, kita akan ingin menjadikannya sebagai kotak
hitam untuk programmer lainnya. Mereka programmer ingin menggunakan fungsi kita tanpa
mengetahui apa yang terjadi di dalam. Bahkan jika kita adalah satu-satunya orang yang
mengerjakan sebuah program, membuat setiap fungsi menjadi kotak hitam terbayar: ada sedikit
rincian yang perlu kita ingat.

Gambar 5.3. Termostat sebagai kotak hitam (black box)

Fungsi-131
 Pemrograman C++

Meski termostat biasanya berwarna putih, Anda bisa menganggapnya sebagai kotak
hitam. Masukannya adalah suhu yang diinginkan, dan outputnya adalah sinyal pemanas atau AC.

5.2. Penerapan Fungsi-Fungsi

Pada bagian ini, kita akan belajar bagaimana menerapkan sebuah fungsi dari spesifikasi
yang diberikan. Kita akan menggunakan contoh yang sangat sederhana: sebuah fungsi untuk
menghitung volume sebuah kubus dengan panjang sisi tertentu.
Saat menulis fungsi ini, Anda perlu
1. Pilih nama untuk fungsi  volume_kubus( ).
2. Deklarasikan sebuah variabel untuk setiap argumen (double panjang_sisi). Variabel ini
adalah disebut variable-variabel parameter.
3. Tentukan jenis nilai kembali/return value (double).

Masukkan semua informasi ini bersama-sama untuk membentuk baris pertama definisi
fungsi:
double volume_kubus(double panjang_sisi)

Selanjutnya, tentukan badan fungsi: pernyataan yang dieksekusi saat fungsi dipanggil.

Saat menentukan sebuah fungsi, Anda memberi nama untuk fungsi tersebut, sebuah
variabel untuk setiap argumen, dan jenis untuk hasilnya.

Gambar 5.4. Fungsi volume_kubus menggunakan panjang sisi tertentu untuk

menghitung volume sebuah kubus.

Fungsi-132
 Pemrograman C++

Volume sebuah kubus dari sisi panjang s adalah s × s × s. Namun, untuk kejelasan yang
lebih besar, variabel parameter kita disebut panjang_sisi, bukan s, jadi kita perlu menghitung
panjang_sisi * panjang_sisi * panjang_sisi.

Kita akan menyimpan nilai ini dalam variabel yang disebut volume:
double volume = panjang_sisi * panjang_sisi* panjang_sisi;

Untuk mengembalikan hasil fungsi, gunakan pernyataan pengembalian:

return volume;

Tubuh sebuah fungsi tertutup dalam kurung kurawal. Berikut adalah fungsi yang lengkap:
double volume_kubus (double panjang_sisi)
{
double volume = panjang_sisi * panjang_sisi* panjang_sisi;
return volume;
}

atau
double volume_kubus (double panjang_sisi)
{
return panjang_sisi * panjang_sisi* panjang_sisi;
}

Mari kita gunakan fungsi ini. Kami akan menyediakan fungsi utama yang memanggil
fungsi volume_kubus dua kali.
int main ()
{
double hasil1 = volume_kubus (2);
double hasil2 = volume_kubus (10);
cout << "Sebuah kubus dengan panjang sisi 2 memiliki volume" << hasil1 << endl;
cout << "Sebuah kubus dengan panjang sisi 10 memiliki volume" << hasil2 <<
endl;
return 0;
}

Bila fungsi dipanggil dengan argumen yang berbeda, fungsi mengembalikan hasil yang
berbeda. Perhatikan panggilan volume_kubus (2). Argumen 2 sesuai dengan variabel parameter
panjang_sisi. Oleh karena itu, dalam panggilan ini, panjang_sisi adalah 2. Fungsi menghitung

Fungsi-133
 Pemrograman C++

panjang_sisi * panjang_sisi * panjang_sisi, atau 2 * 2 * 2. Bila fungsi dipanggil dengan

argumen yang berbeda, misalkan 10, maka fungsi tersebut menghitung 10 * 10 * 10.
Sekarang kita menggabungkan kedua fungsi tersebut ke dalam sebuah program tes.
Karena fungsi utama (main) memanggil volume_kubus, fungsi volume_kubus harus diketahui
sebelum fungsi utama didefinisikan. Hal ini mudah dicapai dengan menempatkan fungsi
volume_kubus pertama dan dan fungsi main terakhir di file sumber.

syntax 5.1 Function Definition

Berikut adalah program yang lengkap. Perhatikan komentar yang menggambarkan

perilaku fungsi. (Pemrograman Tip 5.1 di halaman 199 menjelaskan format komentar.)

Contoh:
// Program latihan 5-1.cpp, Program fungsi
// Program yang terdiri dari 2 fungsi data konstanta
// program menghitung isi kubus
#include <iostream>
#include <iomanip>
using namespace std;
/* menghitung volume sebuah kubus.
@parameter panjang_sisi adalah panjang sisi kubus
@return volume */

// fungsi menghitung volume kubus

double volume_kubus(double panjang_sisi)
{
double volume = panjang_sisi * panjang_sisi * panjang_sisi;

Fungsi-134
 Pemrograman C++

return volume;
// return panjang_sisi * panjang_sisi * panjang_sisi;
}
// Fungsi utama atau fungsi main
int main()
{
double hasil1 = volume_kubus(2);
double hasil2 = volume_kubus(10);
double hasil3 = volume_kubus(5);
cout << "\n\t Program Menghitung Volume Kubus\n" << endl;
cout << "\tKubus panjang sisi 2 memiliki volume : " << setw(4) << hasil1 << endl;
cout << "\tKubus panjang sisi 10 memiliki volume: " << setw(4) << hasil2 << endl;
cout << "\tKubus panjang sisi 5 memiliki volume : " << setw(4) << hasil3 << endl;
cout << “\n\t”;
system("PAUSE");
return 0;
}

Jalan program :

Contoh latihan 5-1a dibawah dengan 3 data yang berbeda yaitu panjang, lebar dan tinggi.

Contoh:
// program latihan5-1-1.cpp
// Program fungsi
// Program yang terdiri dari 2 fungsi variable lebih dari 1
// program menghitung isi ruang ruang
#include <iostream>
#include <iomanip>
using namespace std;
/* menghitung volume sebuah ruang.
@parameter panjang, lebar, tinggi
@return volume */

// fungsi menghitung volume ruang

double volume_ruang(double panjang, double lebar, double tinggi)
{
double volume = panjang * lebar * tinggi;
return volume;
//return panjang * lebar * tinggi;
}

// Fungsi utama atau fungsi main

Fungsi-135
 Pemrograman C++

int main()
{
double hasil1=0, hasil2=0, hasil3=0;
hasil1 = volume_ruang (5,2,3);
hasil2 = volume_ruang (10,7,4);
hasil3 = volume_ruang (7,5,3);
cout << "\n\tMenghitung Volume Ruangan" << endl;
cout << "\tDimensi adalah Panjang, Lebar, Tinggi\n" << endl;
cout << "\tRuang dengan dimensi 5,2,3 memiliki volume : " << setw(4) << hasil1
<< endl;
cout << "\tRuang dengan dimensi 10,7,4 memiliki volume : " << setw(4) << hasil2
<< endl;
cout << "\tRuang dengan dimensi 7,5,3 memiliki volume : " << setw(4) << hasil3
<< endl;
cout << “\n\t”;
system("PAUSE");
return 0;
}

Jalan program :

Tip Pemrograman 5.1. Fungsi komentar-komentar

Kapan pun kita menulis sebuah fungsi, kita harus mengomentari perilakunya.
Komentar untuk pembaca manusia, bukan untuk kompiler, dan tidak ada standar universal
untuk tata letak komentar fungsi.
Dalam buku ini, kita akan menggunakan tata letak berikut ini:
/ * Menghitung volume sebuah kubus.
@parameter panjang_sisi adalah panjang sisi kubus
@return volume * /
double volume_kubus (double panjang_sisi)
{
double volume = panjang_sisi * panjang_sisi * panjang_sisi;
kembali volume;
}

Gaya dokumentasi khusus ini dipinjam dari bahasa pemrograman Java. Ini banyak
didukung oleh alat C++. Baris pertama dari komentar tersebut menggambarkan tujuan fungsi.
Setiap klausa @parameter menjelaskan parameter varibel dan klausa @return menggambarkan

Fungsi-136
 Pemrograman C++

nilai pengembalian.
Perhatikan bahwa komentar fungsi tidak mendokumentasikan pelaksanaannya
(bagaimana fungsinya melakukan apa yang dilakukannya) melainkan desainnya (fungsinya,
masukan, dan hasilnya). Komentar tersebut memungkinkan pemrogram lain untuk
menggunakan fungsi tersebut sebagai "kotak hitam".

Fungsi komentar menjelaskan tujuan fungsi, arti dari variabel parameter dan nilai
kembali, serta persyaratan khusus.

5.3. Parameter Passing

Pada bagian ini, kita memeriksa mekanisme untuk memasukkan argumen ke dalam
fungsi. Ketika sebuah fungsi dipanggil, variabel parameternya dibuat (Istilah lain yang umum
digunakan untuk variabel parameter adalah parameter formal.) Dalam pemanggilan fungsi,
sebuah ekspresi diberikan untuk setiap variabel parameter, yang disebut argumen. (Istilah lain
yang umum digunakan untuk ekspresi ini adalah parameter aktual.) Setiap variabel parameter
diinisialisasi dengan nilai argumen yang sesuai.

Gambar 5.5. Resep untuk pai buah bisa dikatakan menggunakan jenis buah apapun. Di sini,
"buah" adalah contoh dari variabel parameter. Apel dan ceri adalah contoh argumen.

Variabel parameter menyimpan nilai argumen yang diberikan dalam pemanggilan

fungsi.

Perhatikan pemanggilan fungsi yang diilustrasikan pada Gambar 5.6:

Fungsi-137
 Pemrograman C++

double hasil1 = volume_kubus(2);

 Pemanggilan fungsi hasil1=

double hasil1 = volume_kubus(2);
panjang_sisi =

 Inisialisasi fungsi paremeter variabel hasil1=

double hasil1 = volume_kubus(2);
panjang_sisi = 2

 Kembali ke pemanggil hasil1=

double volume = panjang_sisi * panjang_sisi * panjang_sisi;
return volume; panjang_sisi = 2
panjang_sisi = 8

 Setelah pemanggilan fungsi hasil1=

double hasil1 = volume_kubus(2);
panjang_sisi = 2

Gambar 5.6. Parameter Passing

 Parameter variabel panjang_sisi dari fungsi volume_kubus dibuat. 

 Variabel parameter diinisialisasi dengan nilai argumen yang dilewatkan dalam panggilan.

Dalam kasus ini, panjang_sisi diatur ke 2. 

 Fungsi tersebut menghitung persamaan panjang_sisi * panjang_sisi * panjang_sisi, yang

memiliki nilai 8. Nilai itu tersimpan dalam variable volume. 

 Fungsi return. Semua variabelnya dihapus. Nilai kembalian ditransfer ke pemanggil, yaitu

fungsi yang memanggil fungsi volume_kubus. 

Fungsi-138
 Pemrograman C++

Sekarang perhatikan apa yang terjadi dalam volume_kubus panggilan berikutnya (10).
Variabel parameter baru dibuat. (Ingat bahwa variabel parameter sebelumnya telah dihapus saat
panggilan pertama ke volume_kubus dikembalikan.) Diinisialisasi dengan argumen 10, dan
pengulangan proses. Setelah pemanggilan fungsi kedua selesai, variabel-variabelnya akan
dihapus lagi.
Seperti variabel lainnya, variabel parameter hanya dapat disetel ke nilai tipe yang
kompatibel. Sebagai contoh, variabel parameter panjang_sisi dari fungsi volume_kubus memiliki
tipe double. Hal ini berlaku untuk memanggil volume_kubus (2.0) atau volume_kubus (2).
Dalam panggilan terakhir, bilangan bulat 2 secara otomatis dikonversi ke nilai ganda 2.0.
Namun, sebuah panggilan volume_kubus ("dua") tidak legal.

5.4. Nilai-Nilai Return

Kita menggunakan pernyataan return untuk menentukan hasil sebuah fungsi. Saat
pernyataan return diproses, fungsi keluar segera. Perilaku ini mudah untuk menangani kasus luar
biasa diawal:
double volume_kubus (double panjang_sisi)
{
if (panjang_sisi <0)
{
return 0;
}
double volume = panjang_sisi * panjang_sisi * panjang_sisi;
return volume;
// return panjang_sisi * panjang_sisi * panjang_sisi;

Jika fungsi dipanggil dengan nilai negatif untuk panjang_sisi, maka fungsi return 0 dan
sisa fungsinya tidak dieksekusi (Lihat gambar 5.7).

Pernyataan return mengakhiri panggilan fungsi dan menghasilkan hasil fungsi.

Fungsi-139
 Pemrograman C++

Gambar 5.7. Pernyataan return keluar dari fungsi segera

Contoh:
// program latihan5-2.cpp
// Program fungsi data dibatasi yang benar saja yang di proses
// Program yang teridiri dari 2 fungsi
// program menghitung isi kubus input nilai negatif
#include <iostream>
#include <iomanip>
using namespace std;
/* menghitung volume sebuah kubus.
@parameter panjang_sisi adalah panjang sisi kubus
@return volume */

// fungsi menghitung volume kubus

double volume_kubus(double panjang_sisi)
{
if (panjang_sisi <0)
{
return 0;
}
double volume = panjang_sisi * panjang_sisi * panjang_sisi;
return volume;
// return double panjang_sisi * panjang_sisi * panjang_sisi;
}
// Fungsi utama atau fungsi main
int main()
{
double hasil1 = volume_kubus(-2);
double hasil2 = volume_kubus(10);
double hasil3 = volume_kubus(-5);
cout << "\n\tProgram Menghitung Volume Kubus\n" << endl;

Fungsi-140
 Pemrograman C++

cout << "\tKubus dengan panjang sisi -2 memiliki volume : " << setw(5) << hasil1
<< endl;
cout << "\tKubus dengan panjang sisi 10 memiliki volume : " << setw(5) << hasil2
<< endl;
cout << "\tKubus dengan panjang sisi -5 memiliki volume : " << setw(5) << hasil3
<< endl;
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Pada contoh sebelumnya, setiap pernyataan return mengembalikan sebuah konstanta

atau variabel. Sebenarnya, pernyataan return bisa mengembalikan nilai ekspresi apapun. Alih-
alih menyimpan nilai kembali dalam variabel dan mengembalikan variabel, seringkali
dimungkinkan untuk menghilangkan variabel dan mengembalikan ekspresi yang lebih kompleks:
double volume_kubus (double panjang_sisi)
{
return panjang_sisi * panjang_sisi * panjang_sisi;
}

Contoh latihan 5-2a dibawah dengan 3 data yang berbeda yaitu panjang, lebar dan tinggi.

Contoh:
// program latihan5-2-1.cpp
// Program fungsi
// Program yang teridiri dari 2 fungsi
// program menghitung isi ruang nilai negatif
#include <iostream>
#include <iomanip>
using namespace std;
/* menghitung volume sebuah ruang.
@parameter panjang, lebar, tinggi
@return volume */

// fungsi menghitung volume ruang

double volume_ruang(double panjang, double lebar, double tinggi)

Fungsi-141
 Pemrograman C++

{
if (panjang <0 || lebar <0 || tinggi <0)
{
return 0;
}
double volume = panjang * lebar * tinggi;
return volume;
//return panjang * lebar * tinggi;
}

// Fungsi utama atau fungsi main

int main()
{
double hasil1=0, hasil2=0, hasil3=0;
hasil1 = volume_ruang(5,-2,-3);
hasil2 = volume_ruang(10,7,4);
hasil3 = volume_ruang(7,5,-3);
cout << "\n\tMenghitung Volume Ruangan" << endl;
cout << "\tDimensi adalah Panjang, Lebar, Tinggi\n" << endl;
cout << "\tRuang dengan dimensi 5,-2,-3 memiliki volume : " << setw(5) << hasil1
<< endl;
cout << "\tRuang dengan dimensi 10,7,4 memiliki volume : " << setw(5) << hasil2
<< endl;
cout << "\tRuang dengan dimensi 7,5,-3 memiliki volume : " << setw(5) << hasil3
<< endl;
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Jika Anda lebih memilih pendekatan ini, silakan menggunakannya di program Anda.
Anda hanya perlu menyadari satu kelemahan. Kapan pun Anda mengubah nama fungsi atau
salah satu jenis parameter, Anda harus memperbaikinya di kedua tempat: dalam deklarasi dan
definisi.
Penting agar setiap cabang fungsi mengembalikan nilai. Perhatikan fungsi yang salah berikut ini:
double volume_kubus (double panjang_sisi)
{

Fungsi-142
 Pemrograman C++

if (panjang_sisi> = 0)
{
return panjang_sisi * panjang_sisi * panjang_sisi;
} // Kesalahan
}

Misalkan Anda memanggil volume_kubus dengan nilai negatif untuk panjang sisi. Tentu
saja, Anda tidak seharusnya menyebutnya, tapi mungkin itu akibat kesalahan pengkodean.
Karena jika kondisi tidak benar, pernyataan return tidak dijalankan. Namun, fungsinya harus
mengembalikan sesuatu.

Contoh:
// Program latihan5-2-2.cpp, Program fungsi
// Program yang teridiri dari 2 fungsi
// program menghitung isi kubus dengan nilai yang salah
#include <iostream>
#include <iomanip>
using namespace std;

/* menghitung volume sebuah kubus.

@parameter panjang_sisi adalah panjang sisi kubus
@return volume */

// fungsi menghitung volume kubus

double volume_kubus(double panjang_sisi)
{
if (panjang_sisi >= 0)
{
return panjang_sisi * panjang_sisi * panjang_sisi;
}
// SALAH
}

// Fungsi utama atau fungsi main

int main()
{
double hasil1 = volume_kubus(-2);
double hasil2 = volume_kubus(10);
double hasil3 = volume_kubus(-5);
cout << "\n\tProgram Menghitung Volume Kubus" << endl;
cout << "Kubus panjang sisi -2 volumenya : " << setw(5) << hasil1 << endl;
cout << "Kubus panjang sisi 10 volumenya : " << setw(5) << hasil2 << endl;
cout << "Kubus panjang sisi -5 volumenya : " << setw(5) << hasil3 << endl;
cout << “\n\t”;
system("PAUSE");
return 0;
}

Fungsi-143
 Pemrograman C++

Jalan program :

Bergantung pada situasinya, compiler mungkin menandai ini sebagai kesalahan, atau
fungsinya bisa mengembalikan nilai acak. Melindungi terhadap masalah ini dengan
mengembalikan beberapa nilai aman:
double volume_kubus (double panjang_sisi)
{
If (panjang_sisi> = 0)
{
return panjang_sisi * panjang_sisi * panjang_sisi;
}
return 0;
}

Pernyataan terakhir dari setiap fungsi seharusnya berupa pernyataan return_s. Hal ini
memastikan bahwa beberapa nilai akan kembali saat fungsi mencapai akhir.
Untuk data variabel maka program latihan 5-2 atas dapat diubah seperti program
latihan5-2-3 dibawah:

Contoh:
// program latihan5-2-3.cpp
// Program fungsi data dibatasi yang benar saja yang di proses
// Program yang terdiri dari 2 fungsi data variabel
// program menghitung isi kubus
#include <iostream>
#include <iomanip>
using namespace std;
/*menghitung volume sebuah kubus.
@parameter panjang_sisi adalah panjang sisi kubus
@return volume */

// fungsi menghitung volume kubus

double volume_kubus(double panjang_sisi)
{
if (panjang_sisi <0)
{

Fungsi-144
 Pemrograman C++

return 0;
}
double volume = panjang_sisi * panjang_sisi * panjang_sisi;
return volume;
}
// Fungsi utama atau fungsi main
int main()
{
double sisi1=0, sisi2=0, sisi3=0;
char ulang;
do
{
system("cls");
cout << "\tPROGRAM MENGHITUNG VOLUME KUBUS" << endl << endl;
cout << "\t===============================" << endl;
cout << "\tMasukan sisi kubus 1 : "; cin >> sisi1;
cout << "\tMasukan sisi kubus 2 : "; cin >> sisi2;
cout << "\tMasukan sisi kubus 3 : "; cin >> sisi3;
double hasil1 = volume_kubus(sisi1);
double hasil2 = volume_kubus(sisi2);
double hasil3 = volume_kubus(sisi3);
cout << fixed << setprecision (1);
cout << "\tKubus dengan panjang sisi " << setw(5) << sisi1
<< " memiliki volume : " << setw(8) << hasil1 << endl;
cout << "\tKubus dengan panjang sisi " << setw(5) << sisi2
<< " memiliki volume : " << setw(8) << hasil2 << endl;
cout << "\tKubus dengan panjang sisi " << setw(5) << sisi3
<< " memiliki volume : " << setw(8) << hasil3 << endl;
cout << "\n\n\tIngin Kembali ke Menu pilihan lagi? (Y/T)";
cin >> ulang;
}
while(ulang=='Y' || ulang=='y');
cout << "\n\t";
system("PAUSE");
return 0;
}

Untuk data variabel maka program latihan 5-2a atas dapat diubah seperti program
latihan5-2-4 dibawah:
// program latihan5-2-4.cpp
// Program fungsi data dibatasi yang benar saja yang di proses
// Program yang teridiri dari 2 fungsi
// program menghitung isi ruang
#include <iostream>
#include <iomanip>
using namespace std;
/* menghitung volume sebuah ruang.
@parameter panjang, lebar, tinggi adalah panjang, lebar, tinggi ruang
@return volume */

Fungsi-145
 Pemrograman C++

// fungsi menghitung volume ruang

double volume_ruang(double panjang, double lebar, double tinggi)
{
if (panjang<0 || lebar<0 || tinggi<0)
{
return 0;
}
double volume = panjang*lebar*tinggi;
return volume;
}

// Fungsi utama atau fungsi main

int main()
{
double panjang1=0, panjang2=0, panjang3=0;
double lebar1=0, lebar2=0, lebar3=0;
double tinggi1=0, tinggi2=0, tinggi3=0;
char ulang;
do
{
system("cls");
cout << "\tPROGRAM MENGHITUNG VOLUME RUANG" << endl;
cout << "\t===============================================\n\n";
cout << "\tMasukan panjang, lebar dan tinggi ruang 1 : ";
cin >> panjang1;cin >> lebar1;cin >> tinggi1;
cout << "\tMasukan panjang, lebar dan tinggi ruang 2 : ";
cin >> panjang2;cin >> lebar2;cin >> tinggi2;
cout << "\tMasukan panjang, lebar dan tinggi ruang 3 : ";
cin >> panjang3;cin >> lebar3;cin >> tinggi3;
double hasil1 = volume_ruang(panjang1, lebar1, tinggi1);
double hasil2 = volume_ruang(panjang2, lebar2, tinggi2);
double hasil3 = volume_ruang(panjang3, lebar3, tinggi3);
cout << fixed << setprecision (1);
cout << "\tRuang dengan dimensi " << setw(5) << panjang1
<< setw(5) << lebar1 << setw(6) << tinggi1
<< " memiliki volume : " << setw(8) << hasil1 << endl;
cout << "\tRuang dengan dimensi " << setw(5) << panjang2
<< setw(5) << lebar2 << setw(6) << tinggi2
<< " memiliki volume : " << setw(8) << hasil2 << endl;
cout << "\tRuang dengan dimensi " << setw(5) << panjang3
<< setw(5) << lebar3 << setw(6) << tinggi3
<< " memiliki volume : " << setw(8) << hasil3 << endl;
cout << "\n\n\tIngin Kembali ke Menu pilihan lagi? (Y/T)";
cin >> ulang;
}
while(ulang=='Y' || ulang=='y');
cout << "\n\t";
system("PAUSE");
return 0;
}

Fungsi-146
 Pemrograman C++

5.5. Fungsi Tanpa Nilai-Nilai Return

Terkadang, kita perlu melakukan serangkaian instruksi yang tidak menghasilkan nilai.
Jika urutan instruksi itu terjadi beberapa kali, kita akan mengemasnya ke sebuah fungsi. Di C++,
kita menggunakan tipe pengembalian kosong atau tipe void untuk menunjukkan tidak adanya
nilai balik atau nilai-nilai return.
Gunakan jenis pengembalian void untuk menunjukkan bahwa suatu fungsi tidak
menghasilkan nilai. Fungsi void tidak menghasilkan nilai apapun, namun bisa
menghasilkan output.

Inilah contoh khas. Tugas kita adalah mencetak string di dalam kotak, seperti ini:
---------
|Hello|
---------
Namun, string yang berbeda bisa diganti untuk kata Hello. Fungsi untuk tugas ini bisa jadi
didefinisikan sebagai berikut:
void string_kotak (string str)

Sekarang kita mengembangkan fungsi tubuh dengan cara yang biasa, dengan merumuskan
metode umum untuk menyelesaikan tugas.
• Cetak baris yang berisi karakter - sebanyak n+2 kali, di mana n adalah panjang string.
• Cetak sebuah baris berisi string, dikelilingi dengan sebuah ! ke kiri dan kanan
• Cetak baris lain yang berisi karakter – sebanyak n+2 kali.

Berikut adalah implementasi fungsi:

void string_kotak(string str)
{
int n = str.length();
for (int i = 0; i < n + 2; i++) { cout << "-"; }
cout << endl;
cout << "|" << str << "|" << endl;
for (int i = 0; i < n + 2; i++) { cout << "-"; }
cout << endl;
}

Perhatikan bahwa fungsi ini tidak menghitung nilai apapun. Ini melakukan beberapa
tindakan dan kemudian kembali ke pemanggil. (Lihat contoh program ch05 / box.cpp.) Karena

Fungsi-147
 Pemrograman C++

tidak ada nilai pengembalian, Anda tidak dapat menggunakan box_string dalam sebuah ekspresi.
Anda bisa memanggil:
string_kotak ("Hello");

tapi bukan seperti:

hasil = string_kotak ("Hello"); // Error: string_kotak tidak mengembalikan hasilnya.

Contoh:
//program latihan5-3.cpp
// program tanpa nilai return
// program membuat string
#include <iostream>
#include <string>
using namespace std;
/* mencetak sebuah string dalam sebuah kotak.
@parameter str adalah string untuk dicetak */
void string_kotak(string kata)
{
int n = kata.length();
cout << "\t";
for (int i = 0; i < n + 4; i++)
{ cout << "-"; }
cout << endl;
cout << "\t| " << kata << " |" << endl;
cout << "\t";
for (int i = 0; i < n + 4; i++)
{ cout << "-"; }
cout << endl;
}

//Fungsi utama/fungsi main()

int main()
{
cout << "\n";
string_kotak("Hello");
string_kotak("Hello Dunia");
string_kotak("Hello World dunia");
string_kotak("");
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Fungsi-148
 Pemrograman C++

Contoh:
// program latihan5-3a.cpp
// program tanpa nilai return
// program membuat string
// menggunakan escape sequence
#include <iostream>
#include <string>
using namespace std;
/* mencetak sebuah string dalam sebuah kotak.
@parameter str adalah string untuk dicetak */

void kata_dalam_kotak(string kata)

{
int panjang_kata = kata.length();
cout << "\n\t\xDA";
for (int i = 0; i < panjang_kata+2; i++) { cout << "\xC4"; }
cout << "\xBF"; cout << endl;
cout << "\t\xB3 " << kata << " \xB3" << endl;
cout << "\t\xC0";
for (int i = 0; i < panjang_kata+2; i++) { cout << "\xC4"; }
cout << "\xD9"; cout << endl;
}
//Fungsi utama/fungsi main()
int main()
{
kata_dalam_kotak("Hello");
kata_dalam_kotak("Hello World");
kata_dalam_kotak("Hello World Dunia");
kata_dalam_kotak("");
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Fungsi-149
 Pemrograman C++

Contoh:
//program latihan5-3b.cpp
// program membuat string
// program tanpa nilai return
// menggunakan escape sequence
#include <iostream>
#include <string>
using namespace std;
/* mencetak sebuah string dalam sebuah kotak.
@parameter str adalah string untuk dicetak */
void string_kotak(string kata)
{
int panjang_kata = kata.length();
if (panjang_kata==0)
{
return;
}
cout << "\n\t\xDA";
for (int i = 0; i < panjang_kata+2; i++) { cout << "\xC4"; }
cout << "\xBF"; cout << endl;
cout << "\t\xB3 " << kata << " \xB3" << endl;
cout << "\t\xC0";
for (int i = 0; i < panjang_kata+2; i++) { cout << "\xC4"; }
cout << "\xD9"; cout << endl;
}
//Fungsi utama/main()
int main()
{
char pilih, ulang;
do
{
// Input - pilihan
system("cls");;
cout << "\n";
cout << "\n\tJika ingin hanya menampilkan salah satu";
cout << "\n\tPROGRAM KOTAK";
cout << "\n\t1. Kotak Hello";

Fungsi-150
 Pemrograman C++

cout << "\n\t2. Kotak World";

cout << "\n\tPilihan Anda : ";
cin >> pilih;
if(pilih=='1') // alternatif 1
{
string_kotak("Hello");
}
else // alternatif 2
{
if(pilih=='2')
{
string_kotak("Hello World");
}
else // alternatif 3
{
string_kotak("");
cout << "\n\n\tpilihan anda SALAH";
}
}
cout << "\n\n\tIngin Kembali ke Menu pilihan lagi? (Y/T)";
cin >> ulang;
}
while(ulang=='Y' || ulang=='y');
cout << "\n\t";
system("PAUSE");
return 0;
}

Jika kita ingin kembali dari fungsi void sebelum mencapai akhir, Anda menggunakan
pernyataan pengembalian tanpa nilai. Sebagai contoh,
void string_kotak(string kata)
{
int panjang_kata = kata.length();
if (panjang_kata == 0)
{
return; // segera kembali
}
...
}

Fungsi-151
 Pemrograman C++

5.6. Ruang Lingkup Variabel dan Variabel Global

Dimungkinkan untuk menentukan nama variabel yang sama lebih dari satu kali
dalam sebuah program. Bila nama variabel digunakan, kita perlu mengetahui definisi mana yang
dimilikinya. Pada bagian ini, kita membahas peraturan untuk menangani beberapa definisi
dengan nama yang sama.
Variabel yang didefinisikan dalam suatu fungsi dapat dilihat dari titik di mana ia
didefinisikan sampai akhir blok dimana ia didefinisikan. Daerah ini disebut ruang lingkup
variabel.
Ruang lingkup variabel adalah bagian dari program yang terlihat.

Perhatikan variabel volume dalam contoh berikut:

Setiap variabel volume didefinisikan dalam fungsi terpisah, dan cakupannya tidak tumpang
tindih.

Gambar 5.8. Dengan cara yang sama bahwa ada jalan bernama "Jalan Utama/
Main Street" di berbagai kota, program C ++ dapat memiliki banyak variabel
dengan nama yang sama.

Fungsi-152
 Pemrograman C++

Tidaklah sah untuk menentukan dua variabel dengan nama yang sama dalam lingkup
yang sama. Misalnya, berikut ini tidak legal:
int main()
{
double volume = volume_kubus(2);
double volume = volume_kubus(10);
// ERROR: tidak dapat menentukan variabel volume lain dalam lingkup ini
...
}

Namun, kita dapat menentukan variabel lain dengan nama yang sama di blok bertingkat.
Di sini, kita mendefinisikan dua variabel yang disebut jumlah.
double penarikan(double saldo, double jumlah)
{
if (...)
{
double jumlah = 10; // variabel lain bernama jumlah
...
}
...
}

Ruang lingkup variabel parameter jumlah adalah keseluruhan fungsi, kecuali di dalam
blok nested blok/ blok bersarang. Di dalam blok bersarang, jumlah mengacu pada variabel yang
didefinisikan di blok tersebut. Kita mengatakan bahwa variabel didalam blok membayangi
variabel yang didefinisikan di blok luar. Kita harus menghindari situasi yang berpotensi
membingungkan ini dalam fungsi yang kita tulis, cukup dengan mengganti nama salah satu
variabel.
Sebuah variabel dalam bayangan nested block adalah variabel dengan nama
yang sama di blok luar.

Variabel yang didefinisikan di dalam fungsi disebut variabel lokal. C++ juga
mendukung variabel global: variabel yang didefinisikan di luar fungsi. Variabel global dapat
dilihat oleh semua fungsi yang ditentukan setelahnya. Misalnya, header <iostream>
mendefinisikan variabel global cin dan cout.
Variabel lokal didefinisikan di dalam sebuah fungsi, variabel global
didefinisikan di luar fungsi.

Fungsi-153
 Pemrograman C++

Berikut adalah contoh variabel global:

int saldo = 10000; // variable global
void tarikan(double jumlah)
{
if (saldo >= jumlah)
{
saldo = saldo - jumlah;
}
}
int main()
{
tarikan(1000);
cout << saldo << endl;
return 0;
}

Ruang lingkup variable saldo membentang pada fungsi fungsi penarikan dan fungsi
utama. Umumnya, variabel global bukanlah ide bagus. Ketika beberapa fungsi memperbarui
variabel global, hasilnya bisa sulit diprediksi. Terutama dalam program yang lebih besar yang
dikembangkan oleh banyak program, sangat penting bahwa efek dari masing-masing fungsi
menjadi jelas dan mudah dipahami. Kita harus menghindari variabel global dalam program
kita.
Hindari variabel global dalam program.

5.7. Parameter Referensi

Jika kita ingin menulis sebuah fungsi yang mengubah nilai argumen, kita harus
menggunakan parameter acuan untuk memungkinkan perubahan tersebut. Kita pertama kali
menjelaskan mengapa jenis parameter yang berbeda diperlukan, maka kita menunjukkan sintaks
untuk parameter referensi.
Perhatikan fungsi yang mensimulasikan penarikan sejumlah uang dari rekening bank,
asalkan tersedia cukup dana. Jika jumlah uang tidak mencukupi, penalti $ 10 akan dikurangkan.
Fungsi tersebut akan digunakan sebagai berikut:

double tabungan_harry = 1000;

tarikan(tabungan_harry, 100); // sekarang tabungan_harry adalah 900
tarikan(tabungan_harry, 1000); // dana tidak mencukupi.

Fungsi-154
 Pemrograman C++

// Sekarang tabungan_harry adalah 890

Inilah usaha pertama:

void tarikan(double saldo, double jumlah) // tidak bekerja
{
const double PENALTY = 10;
if (saldo >= jumlah)
{
saldo = saldo - jumlah;
}
else
{
saldo = saldo - PENALTY;
}
}

Tapi ini tidak berhasil.

Contoh:
//Program latihan5-4.cpp
// program tabungan
// menggunakan fungsi
#include <iostream>
using namespace std;

/* penarikan jumlah dari saldo yang diberikan, atau penarikan

    adalah sebuah hukuman/pinalti jika saldo tidak mencukupi.
    @parameter saldo adalah saldo untuk melakukan penarikan
    @parameter jumlah adalah jumlah untuk penarikan */
void tarikan(double saldo, double jumlah)
{
const double PENALTY = 10;
if (saldo >= jumlah)
{
saldo = saldo - jumlah;
}
else
{
saldo = saldo - PENALTY;
}
}
//fungsi utama/main()
int main()
{

Fungsi-155
 Pemrograman C++

double tabungan_harry = 1000;

double tabungan_sally = 500;
double ambil_harry = 100;
double ambil_sally = 150;
cout << "\n\tBesar Tabungan Harry $ " << tabungan_harry << " dan Sally $ "
<< tabungan_sally << endl;
cout << "\t================================================";
cout << "\n\tHarry mengambil Tabungan ($) = " << ambil_harry;
tarikan(tabungan_harry, ambil_harry); // sekarang tabungan_harry adalah 900
ambil_harry = 1000;
cout << "\n\tHarry mengambil Tabungan ($) = " << ambil_harry;
tarikan(tabungan_harry, ambil_harry); // dana tidak mencukupi
// sekarang tabungan_harry adalah 890
tarikan(tabungan_sally, ambil_sally);
cout << "\n\tSally mengambil Tabungan ($) = " << ambil_sally << endl;
cout << "\n\tTabungan Harry Sekarang ($) = " << tabungan_harry;
cout << "\n\tTabungan Sally Sekarang ($) = " << tabungan_sally << endl;
cout << "\t================================================" << endl << endl;
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Mari kita berjalan melalui fungsi call tarikan (tabungan_harry, 100) -lihat Gambar 5.9.

Ketika fungsi dimulai, parameter variabel saldo dibuat  dan isi ke nilai yang sama dengan
tabungan_harry, dan jumlah diisi ke 100 . Kemudian saldo dimodifikasi . Tentu saja,
modifikasi itu tidak berpengaruh pada tabungan_harry, karena saldo adalah variabel terpisah.
Ketika fungsi return, saldo dilupakan, dan tidak ada uang yang ditarik dari tabungan_harry

.

Fungsi-156
 Pemrograman C++

 Pemanggilan fungsi Tabungan_harry= 1000

tarikan(tabungan_harry,100);
saldo =
jumlah=

 Inisialisasi parameter variable fungsi Tabungan_harry= 1000

tarikan(tabungan_harry,100);
saldo = 1000
jumlah= 100

 Kembali ke pemanggil Tabungan_harry= 1000

saldo = saldo - jumlah;
saldo = 900
jumlah= 100

 Setelah pemanggilan fungsi Tabungan_harry= 1000

Gambar 5.9. Bila nilai dan tabungan_s adalah parameter Nilai

Parameter variabel saldo disebut parameter nilai, karena diinisialisasi dengan nilai
argumen yang diberikan. Semua fungsi yang telah kita tulis sejauh ini menggunakan parameter
nilai. Dalam situasi ini, kita hanya tidak ingin saldo memiliki nilai yang sama dengan
tabungan_harry. Kita menginginkan saldo untuk mengacu pada variabel tabungan_harry
aktual (atau tabungan_joe atau variabel apa pun yang disertakan dalam panggilan tersebut). Isi
variabel itu harus diperbarui.

Memodifikasi sebuah nilai parameter tidak berpengaruh pada pemanggil.

Kita menggunakan parameter referensi saat kita ingin memperbarui variabel yang
diberikan dalam pemanggilan fungsi. Ketika kita membuat saldo menjadi parameter referensi,
maka saldo bukanlah variabel baru namun mengacu pada variabel yang ada. Perubahan saldo
sebenarnya adalah perubahan pada variabel yang mengacu pada panggilan itu.

Fungsi-157
 Pemrograman C++

Parameter referensi mengacu pada variabel yang diberikan dalam

pemanggilan fungsi.

Gambar 5.10. menunjukkan perbedaan antara nilai dan parameter referensi.

Gambar 5.10. Nilai referensi dan nilai parameter-parameter

Untuk menunjukkan parameter referensi, Anda menempatkan sebuah & setelah jenis
variabel.
void tarikan(double& saldo, double jumlah)

Tipe double& dibaca "referensi ke double" atau, disingkat, "double ref". Fungsi
tarikan sekarang memiliki dua variabel parameter: satu dari tipe "double ref" dan parameter
nilai lainnya tipe double. Tubuh fungsi tidak berubah. Yang telah berubah adalah arti dari tugas
ke variabel saldo.
Tugas
saldo = saldo - jumlah;

sekarang ubah variabel yang dilewatkan ke fungsi (lihat Gambar 5.11).

 Pemanggilan fungsi Tabungan_harry= 1000

Fungsi-158
 Pemrograman C++

tarikan(tabungan_harry,100); saldo =
jumlah=

 Inisialisasi parameter variable fungsi Tabungan_harry= 1000

tarikan(tabungan_harry,100);
saldo =
jumlah= 100

 Kembali ke pemanggil Tabungan_harry= 900

saldo = saldo - jumlah;
saldo =
jumlah= 100

 Setelah pemanggilan fungsi Tabungan_harry= 900

Gambar 5.11. Bila saldo adalah parameter referensi

Gambar 5.12. Parameter referensi untuk bank

soldo_s seperti kartu ATM - ini
memungkinkan Anda mengubah saldo. Sebaliknya,
parameter nilai hanya bisa memberi tahu Anda
tentang saldo.

Misalnya, panggilan
tarikan (tabungan_harry, 100);
Ubahlah variabel tabungan_harry, dan panggil.
tarikan (tabungan_sally, 150);

Ubahlah variabel tabungan_sally, dan panggil

Fungsi-159
 Pemrograman C++

Argumen untuk parameter referensi harus selalu berupa variabel. Ini akan menjadi
kesalahan untuk memasok bilangan:
tarikan (1000, 500); // Error: argumen untuk parameter referensi harus berupa variabel

Alasannya jelas - fungsi memodifikasi parameter referensi, namun tidak mungkin

mengubah nilai sebuah angka. Untuk alasan yang sama, kita tidak dapat memberikan persamaan:
tarikan (tabungan_harry + 150, 500); // Error: argumen untuk parameter referensi harus berupa
variabel

Memodifikasi parameter referensi memperbarui variabel yang diberikan dalam

panggilan

Contoh:
//program latihan5-4a.cpp
// program tabungan
// menggunakan fungsi
#include <iostream>
using namespace std;

/*penarikan jumlah dari saldo yang diberikan, atau penarikan

    adalah sebuah hukuman/pinalti jika saldo tidak mencukupi.
    @parameter saldo adalah saldo untuk melakukan penarikan
    @parameter jumlah adalah jumlah untuk penarikan */

void tarikan(double& saldo, double jumlah)

{
const double PENALTY = 10;
if (saldo >= jumlah)
{
saldo = saldo - jumlah;
}
else
{
saldo = saldo - PENALTY;
}
}
//fungsi utama/main()
int main()
{
double tabungan_harry = 1000;
double tabungan_sally = 500;
double ambil_harry = 100;
double ambil_sally = 150;
cout << "\n\tBesar Tabungan Harry $ " << tabungan_harry << " dan Sally $ "

Fungsi-160
 Pemrograman C++

<< tabungan_sally << endl;

cout << "\t================================================";
cout << "\n\tHarry mengambil Tabungan ($) = " << ambil_harry;
tarikan(tabungan_harry, ambil_harry); // sekarang tabungan_harry adalah 900
ambil_harry = 1000;
cout << "\n\tHarry mengambil Tabungan ($) = " << ambil_harry;
tarikan(tabungan_harry, ambil_harry); // dana tidak mencukupi
// sekarang tabungan_harry adalah 890
tarikan(tabungan_sally, ambil_sally);
cout << "\n\tSally mengambil Tabungan ($) = " << ambil_sally << endl;
cout << "\n\tTabungan Harry Sekarang ($) = " << tabungan_harry;
cout << "\n\tTabungan Sally Sekarang ($) = " << tabungan_sally << endl;
cout << "\t================================================" << endl << endl;
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Jika kita ingin penarikan tabungan berdasarkan input yang kita berikan maka
program diatas dapat dimodifikasi seperti contoh berikut ini.

Contoh:
//program latihan5-4b.cpp
// program tabungan
// menggunakan fungsi dengan input variabel
#include <iostream>
using namespace std;
/** penarikan jumlah dari saldo yang diberikan, atau penarikan
    adalah sebuah hukuman/pinalti jika saldo tidak mencukupi.
    @parameter saldo adalah saldo untuk melakukan penarikan
    @parameter jumlah adalah jumlah untuk penarikan */
void tarikan(double& saldo, double jumlah)
{
const double PENALTY = 10;
if (saldo >= jumlah)
{

Fungsi-161
 Pemrograman C++

saldo = saldo - jumlah;

}
else
{
saldo = saldo - PENALTY;
}
}
//fungsi utama/main()
int main()
{
double tabungan_harry = 1000, tabungan_sally = 500;
double ambil1=0, ambil2=0;
char ulang;
do
{
cout << "\n\tBesar Tabungan Harry $ " << tabungan_harry << " dan Sally $ "
<< tabungan_sally << endl;
cout << "\t================================================" << endl << endl;
cout << "\tTabungan Harry Yang Diambil ($) = ";
cin >> ambil1;
cout << "\tTabungan Sally Yang Diambil ($) = ";
cin >> ambil2;
tarikan(tabungan_harry, ambil1);
tarikan(tabungan_sally, ambil2);
if(ambil1>tabungan_harry && ambil2<tabungan_sally)
{
cout << "\n\tTabungan Harry Sekarang ($) = " << tabungan_harry <<
" ==> Harry Kena PENALTI" << endl;
cout << "\n\tTabungan Sally Sekarang ($) = " << tabungan_sally << endl;
}
else if(ambil1<tabungan_harry && ambil2>tabungan_sally)
{
cout << "\n\tTabungan Harry Sekarang ($) = " << tabungan_harry << endl;
cout << "\n\tTabungan Sally Sekarang ($) = " << tabungan_sally <<
" ==> Sally Kena PENALTI" << endl;
}
else if(ambil1>tabungan_harry && ambil2>tabungan_sally)
{
cout << "\n\tTabungan Harry Sekarang ($) = " << tabungan_harry <<
" ==> Harry Kena PENALTI" << endl;
cout << "\n\tTabungan Sally Sekarang ($) = " << tabungan_sally <<
" ==> Sally Kena PENALTI" << endl;
}
else
{
cout << "\n\tTabungan Harry Sekarang ($) = " << tabungan_harry << endl;
cout << "\n\tTabungan Sally Sekarang ($) = " << tabungan_sally << endl;
}
cout << "\t================================================" << endl << endl;
cout << "\n\tIngin menggambil Tabungan lagi?(Y/T): ";
cin >> ulang;

Fungsi-162
 Pemrograman C++

cout << endl; cout << endl;

}
while(ulang=='Y' || ulang=='y');
cout << "\n\t";
system("PAUSE");
return 0;
}
Buatlah contoh program berikut ini:
Contoh
//Program latihan5-5.cpp
// Program menggunakan fungsi, input di fungsi main() dan
// proses di fungsi luas()
// Program menghitung luas bujursangkar
#include <iostream>
using namespace std;
// Fungsi menentukan luas bujur sangkar Nama fungsi luas()
double luas(double sisi)
{
return(sisi*sisi);
}
// Fungsi main ()
int main()
{
double luas_bs,sisi_bs;
char ulang;
do
{
system("cls");
cout << "\n\tProgram menghitung luas bujursangkar";
cout << "\n\t====================================\n\n";
// Input sisi bujursangkar
cout << "\tSisi Bujursangkar = ";
cin >> sisi_bs;
// Menghitung luas bujursangkar
luas_bs=luas(sisi_bs);
cout << "\n\tLuas Bujursangkar = " << luas_bs;
cout << "\n\n\tIngin menghitung lagi?(Y/T): ";
cin >> ulang;
cout << endl; cout << endl;
}
while(ulang=='Y' || ulang=='y');
system("PAUSE");
return 0;
}

Contoh:
// Program latihan5-5a.cpp
// Program menggunakan fungsi, input dan proses di fungsi luas()
// Program menghitung luas bujursangkar

Fungsi-163
 Pemrograman C++

#include <iostream>
using namespace std;
// Fungsi menentukan luas bujur sangkar Nama fungsi luas()
double luas()
{
double sisi;
cout << "\n\tMasukkan sisi = ";
cin >> sisi;
return(sisi*sisi);
}
// Fungsi main ()
int main()
{
double luas_bs, sisi_bs;
char ulang;
do
{
system("cls");
cout << "\n\tProgram menghitung luas bujursangkar";
cout << "\n\t====================================\n\n";
// Menghitung luas bujursangkar
luas_bs=luas();
cout << "\n\n\tLuas Bujursangkar = " << luas_bs;
cout << "\n\n\tIngin menghitung lagi?(Y/T): ";
cin >> ulang;
cout << endl; cout << endl;
}
while(ulang=='Y' || ulang=='y');
system("PAUSE");
return 0;
}

Untuk input variable yang lebih dari satu (dua, tiga dan sebagainya) maka contoh
program berikut dapat kita pelajari:

Contoh:
// program latihan 5-6.cpp
// Program menggunakan fungsi, input di fungsi main() dan
// proses di fungsi luas()
// Program menghitung luas segiempat
#include <iostream>
using namespace std;
// Fungsi menentukan luas segiempat Nama Fungsi luas()
double luas(double panjang, double lebar)
{
return(panjang*lebar);
}
// fungsi main()
main()

Fungsi-164
 Pemrograman C++

{
double panjang_segiempat,lebar_segiempat,luas_segiempat;
double panjang_segiempat2,lebar_segiempat2,luas_segiempat2;
double panjang_segiempat3,lebar_segiempat3,luas_segiempat3;

char ulang;
do
{
system("cls");
cout << "\n\tProgram menghitung luas segiempat\n";
cout << "\t=================================\n\n";
// Input panjang dan lebar segiempat */
cout << "\tPanjang 1: ";
cin >> panjang_segiempat; cout << endl;
cout << "\tLebar 1: ";
cin >> lebar_segiempat;
cout << "\tPanjang 2: ";
cin >> panjang_segiempat2; cout << endl;
cout << "\tLebar 2: ";
cin >> lebar_segiempat2;
cin >> panjang_segiempat3; cout << endl;
cout << "\tLebar 3: ";
cin >> lebar_segiempat3;
// Menghitung luas segiempat
luas_segiempat=luas(panjang_segiempat,lebar_segiempat);
luas_segiempat2=luas(panjang_segiempat2,lebar_segiempat2);
luas_segiempat3=luas(panjang_segiempat3,lebar_segiempat3);

cout << "\n\tLuas Segiempat 1= " << luas_segiempat;

cout << "\n\tLuas Segiempat 2= " << luas_segiempat2;
cout << "\n\tLuas Segiempat 3= " << luas_segiempat3;
cout << "\n\n\tIngin menghitung lagi?(Y/T): ";
cin >> ulang;
cout << endl;
}
while(ulang=='Y' || ulang=='y');
system("PAUSE");
return 0;
}

Contoh:
// Program latihan5-6a.cpp
// Program menggunakan fungsi, input dan proses di fungsi luas()
// Program menghitung luas segiempat */
#include <iostream>
using namespace std;
// Fungsi menentukan luas segiempat Nama Fungsi luas()
double luas()
{
double panjang=0, lebar=0;

Fungsi-165
 Pemrograman C++

// Input panjang dan lebar segiempat

cout << "\n\tPanjang = ";
cin >> panjang;
cout << "\n\tLebar = ";
cin >> lebar;
// Menghitung luas segiempat
return(panjang*lebar);
}
// fungsi main()
main()
{
char ulang;
do
{
system("cls");
cout << "\n\tProgram menghitung luas segiempat\n";
cout << "\t=================================\n\n";
// Menghitung luas segiempat
double luas_segiempat1=luas();
double luas_segiempat2=luas();
double luas_segiempat3=luas();
cout << "\tLuas Segiempat 1= " << luas_segiempat1; cout << endl; cout << endl;
cout << "\tLuas Segiempat 2= " << luas_segiempat2; cout << endl; cout << endl;
cout << "\tLuas Segiempat 3= " << luas_segiempat3; cout << endl; cout << endl;
cout << "\tIngin menghitung lagi?(Y/T): ";
cin >> ulang;
cout << endl;
}
while(ulang=='Y' || ulang=='y');
system("PAUSE");
return 0;
}

Contoh:
// Program latihan5-6b.cpp
// Program menggunakan fungsi, input di fungsi main() dan
// proses di fungsi luas
// Program menghitung luas segiempat */
#include <iostream>
#include <iomanip>
using namespace std;
// Fungsi menentukan luas segiempat Nama Fungsi luas()
double luas(double panjang , double lebar)
{
return(panjang*lebar);
}
// fungsi main()
main()
{

Fungsi-166
 Pemrograman C++

double panjang_segiempat,lebar_segiempat,luas_segiempat;
double panjang_segiempat2,lebar_segiempat2,luas_segiempat2;
char ulang;
do
{
system("cls");
cout << "\n\tProgram menghitung luas 2 segiempat";
cout << "\n\t===================================";
// Input panjang dan lebar segiempat */
cout << "\n\n\tPanjang segiempat 1 = ";
cin >> panjang_segiempat;
cout << "\tLebar segiempat 1 = ";
cin >> lebar_segiempat;
cout << "\n\n\tPanjang segiempat 2 = ";
cin >> panjang_segiempat2;
cout << "\tLebar segiempat 2 = ";
cin >> lebar_segiempat2;
// Menghitung luas segiempat
luas_segiempat=luas(panjang_segiempat,lebar_segiempat);
luas_segiempat2=luas(panjang_segiempat2,lebar_segiempat2);

cout << "\n\n\tLuas Segiempat 1 = " << setw(5) << luas_segiempat;

cout << "\n\tLuas Segiempat 2 = " << setw(5) << luas_segiempat2;

cout << "\n\n\tIngin menghitung lagi?(Y/T): ";

cin >> ulang;
cout << endl;
}
while(ulang=='Y' || ulang=='y');
cout << "\t";
system("PAUSE");
return 0;
}

5.8. Fungsi Rekursif (opsional)

Fungsi rekursif adalah fungsi yang memanggil dirinya sendiri. Ini tidak biasa seperti yang
terdengar pada awalnya. Misalkan kita menghadapi tugas berat membersihkan seluruh rumah.
Kita mungkin mengatakannya kepada diri sendiri, "Saya akan memilih kamar dan
membersihkannya, dan kemudian saya akan membersihkan kamar lain." Dengan kata lain, tugas
pembersihan memanggil dirinya sendiri, tapi dengan masukan yang lebih sederhana. Akhirnya,
semua ruangan akan dibersihkan.
Di C++, fungsi rekursif menggunakan prinsip yang sama. Inilah contoh khas. Kita ingin
mencetak pola segitiga seperti ini:
[]

Fungsi-167
 Pemrograman C++

[][]
[][][]
[][][][]

Secara khusus, tugas kita adalah menyediakan sebuah fungsi

void cetak_segitiga (int panjang_sisi)

Segitiga yang diberikan di atas dicetak dengan memanggil cetak_segitiga (4). Untuk
melihat bagaimana rekursi membantu, perhatikan bagaimana sebuah segitiga dengan panjang sisi
4 dapat diperoleh dari segitiga dengan panjang sisi 3.
[]
[][]
[][][]
[][][][]

Cetak segitiga dengan panjang sisi 3.

Cetak garis dengan empat [].

Secara umum, untuk panjang sisi bebas:

Cetak segitiga dengan panjang sisi - 1.
Cetak garis dengan panjang sisi [].

Berikut adalah pseudocode yang diterjemahkan ke C++:

void cetak_segitiga(int panjang_sisi)
{
Cetak_segitiga(panjang_sisi - 1);
for (int i = 0; i < panjang_sisi; i++)
{
cout << "[]";
}
cout << endl;
}

Hanya ada satu masalah dengan ide ini. Bila panjang sisi adalah kecil dari 1, kita tidak
mau memanggil cetak_segitiga (0), cetak_segitiga(-1), dan seterusnya. Solusinya hanya untuk

Fungsi-168
 Pemrograman C++

memperlakukan ini sebagai kasus khusus, dan jangan sampai mencetak apapun ketika
panjangnya kurang dari 1.
void cetak_segitiga(int panjang_sisi)
{
if (panjang_sisi < 1)
{
return;
}
cetak_segitiga (panjang_sisi - 1);
for (int i = 0; i < panjang_sisi; i++)
{
cout << "[]";
}
cout << endl;
}

Lihatlah fungsi cetak_segitiga sekali lagi dan perhatikan betapa masuk akalnya itu. Jika
panjang sisi adalah 0, tidak ada yang perlu dicetak. Bagian selanjutnya sama masuk akal. Cetak
segitiga yang lebih kecil dan jangan pikirkan mengapa hal itu berhasil. Kemudian cetak deretan
[]. Yang jelas, hasilnya adalah segitiga dari ukuran yang diinginkan.
Ada dua persyaratan utama untuk memastikan bahwa rekursi berhasil:
• Setiap panggilan rekursif harus menyederhanakan tugas dengan cara tertentu.
• Harus ada kasus khusus untuk menangani tugas yang paling sederhana secara langsung.

Fungsi cetak_segitiga memanggil dirinya sendiri lagi dengan panjang sisi yang lebih kecil
dan lebih kecil. Akhirnya panjang sisi harus mencapai 0, dan fungsi berhenti memanggil dirinya
sendiri.
Inilah yang terjadi saat kita mencetak segitiga dengan panjang sisi 4.
• Panggil cetak_segitiga(4) panggil cetak_segitiga(3).
• Panggil cetak_segitiga(3) panggil cetak_segitiga(2).
• Panggil cetak_segitiga(2) panggil cetak_segitiga(1).
• Panggil cetak_segitiga(1) panggil cetak_segitiga(0).
• Panggil cetak_segitiga(0) kembali, tidak melakukan apapun.
• Panggil cetak_segitiga(1) cetak [].
• Panggil cetak_segitiga(2) cetak [] [].
• Panggil cetak_segitiga(3) cetak [] [] [].

Fungsi-169
 Pemrograman C++

• Panggil cetak_segitiga(4) cetak [] [] [] [].

Pola panggilan fungsi rekursif terlihat rumit, dan kunci sukses desain fungsi rekursif
bukan untuk memikirkannya.

Contoh:
// Program Latihan 5-9.cpp
// Program menggunakan fungsi rekursif
// Program segitiga
#include <iostream>
using namespace std;

/* cetak segitiga dengan memberikan panjang sisi

@parameter panjang_sisi adalah panjang sisi (jumlah dari [] sebagai dasar) */
void cetak_segitiga(int panjang_sisi)
{
if (panjang_sisi < 1)
{
return;
}
cetak_segitiga(panjang_sisi-1);
cout << "\t";
for(int i = 1; i <= panjang_sisi; i++)
{
cout << "[]";
}
cout << endl;
}
//fungsi utama/main()
int main()
{
int input;
char ulang;
do
{
system("cls");
cout << "\n\tPROGRAM CETAK SEGITIGA";
cout << "\n\t======================\n";
cout << "\n\tMasukkan Panjang Sisi : ";
cin >> input;
cout << "\n";
cetak_segitiga(input);
cout << "\n\tIngin menghitung lagi?(Y/T): ";
cin >> ulang;
cout << endl; cout << endl;
}
while(ulang=='Y' || ulang=='y');

Fungsi-170
 Pemrograman C++

cout << "\n\t";

system("PAUSE");
return 0;
}

Jalan program :

Rekursi tidak terlalu diperlukan untuk mencetak bentuk segitiga. Anda dapat
menggunakan loop bersarang, seperti ini:
for (int i = 0; i <panjang_sisi; i ++)
{
for (int j = 0; j <=i; j ++)
{
cout << "[]";
}
cout << endl;
}

Contoh:
// Program Latihan 5-9a.cpp
// Program menggunakan fungsi dengan nested for
// Program segitiga
#include <iostream>
using namespace std;
/* cetak segitiga dengan memberikan panjang sisi
@parameter panjang_sisi adalah panjang sisi (jumlah dari [] sebagai dasar) */

void cetak_segitiga(int panjang_sisi)

{
if (panjang_sisi < 1)
{
return;
}
for(int i = 0; i <panjang_sisi; i ++)
{
cout << "\t";

Fungsi-171
 Pemrograman C++

for(int j = 0; j <=i; j ++)

{
cout << "[]";
}
cout << endl;
}
}

//fungsi utama/main()
int main()
{
char ulang;
do
{
system("cls");
cout << "\n\tPROGRAM CETAK SEGITIGA";
cout << "\n\t======================\n";
cout << "\n\tMasukkan Panjang Sisi : ";
int input;
cin >> input;
cout << "\n";
cetak_segitiga(input);
cout << "\n\tIngin menghitung lagi?(Y/T): ";
cin >> ulang;
cout << endl; cout << endl;
}
while(ulang=='Y' || ulang=='y');
cout << "\n\t";
system("PAUSE");
return 0;
}

Jalan program :

Namun, pasangan loop ini agak rumit. Banyak orang menganggap solusi rekursif lebih
sederhana untuk dipahami.

Fungsi-172