Menyusun Program dengan Fungsi

Belajar C++ · Materi 09

Menyusun Program dengan Fungsi

Mengenal cara membagi program menjadi bagian-bagian kecil, membuat fungsi sendiri, menggunakan parameter, dan mengembalikan nilai untuk membangun program yang lebih terstruktur.

Bayangkan kamu diminta membuat program untuk mengelola nilai murid. Program tersebut harus menerima beberapa nilai, menghitung jumlahnya, mencari rata-rata, menentukan nilai tertinggi, dan menampilkan hasil akhirnya.

Jika seluruh instruksi ditulis secara berurutan di dalam satu fungsi main(), program mungkin masih dapat berjalan. Namun, semakin banyak pekerjaan yang harus dilakukan, semakin panjang pula kode yang harus kita tulis.

Masalahnya bukan hanya jumlah baris kode. Ketika program semakin besar, kita akan lebih sulit memahami bagian mana yang bertugas menerima data, bagian mana yang menghitung, dan bagian mana yang menampilkan hasil.

Bagaimana jika setiap pekerjaan dapat dipisahkan menjadi bagian tersendiri? Misalnya, ada satu bagian khusus untuk menghitung rata-rata, bagian lain untuk mencari nilai tertinggi, dan bagian lainnya untuk menampilkan hasil.

Dengan cara tersebut, kita tidak perlu menumpuk seluruh instruksi dalam satu tempat. Kita dapat menyusun program menjadi beberapa bagian yang masing-masing memiliki tugas tertentu.

Dalam C++, salah satu cara untuk melakukannya adalah menggunakan fungsi atau function.

Hubungkan dengan materi sebelumnya

Memahami variabel, tipe data, dan konstanta
Membuat program yang dapat mengambil keputusan
Mengulang instruksi dengan perulangan
Mengelola banyak data dengan array

---

1. Mengapa Kita Membutuhkan Fungsi?

Sebelum mempelajari cara membuat fungsi, mari kita lihat terlebih dahulu masalah yang ingin diselesaikan.

Misalnya, kita memiliki program sederhana yang menghitung luas persegi panjang. Program tersebut menerima panjang dan lebar, kemudian menghitung hasil perkaliannya.

#include <iostream>
using namespace std;

int main() {
    int panjang = 10;
    int lebar = 5;

    int luas = panjang * lebar;

    cout << "Luas persegi panjang: "
         << luas << endl;

    return 0;
}

Program tersebut cukup sederhana. Namun, bayangkan jika kita ingin menghitung luas persegi panjang beberapa kali, misalnya untuk beberapa ruangan dengan ukuran berbeda.

Kita dapat menuliskan kembali rumus perkalian panjang dan lebar setiap kali diperlukan. Akan tetapi, cara tersebut membuat instruksi yang sama berulang kali ditulis.

Bagaimana jika proses menghitung luas cukup dibuat satu kali, lalu dipanggil setiap kali dibutuhkan?

Di sinilah fungsi menjadi berguna. Kita dapat membuat satu fungsi yang bertugas menghitung luas persegi panjang. Ketika program membutuhkan perhitungan tersebut, kita cukup memanggil fungsi yang sudah dibuat.

Gagasan utama: Fungsi memungkinkan kita mengelompokkan instruksi berdasarkan tugas tertentu. Setelah dibuat, fungsi dapat dipanggil kembali dari bagian program lain tanpa harus menuliskan ulang seluruh instruksinya.

2. Apa Itu Fungsi dalam C++?

Fungsi adalah sekumpulan instruksi yang diberi nama dan dirancang untuk menjalankan tugas tertentu. Fungsi dapat dipanggil ketika program membutuhkan tugas tersebut.

Untuk membayangkannya, anggap sebuah program seperti sebuah organisasi yang memiliki beberapa bagian pekerjaan. Ada bagian yang bertugas menerima data, bagian yang menghitung, dan bagian yang menampilkan hasil.

Setiap bagian memiliki tanggung jawab sendiri. Ketika suatu pekerjaan diperlukan, bagian yang sesuai akan menjalankan tugasnya.

Fungsi bekerja dengan prinsip yang serupa. Kita dapat membuat beberapa fungsi dengan tugas berbeda, kemudian menghubungkannya melalui pemanggilan fungsi.

Contoh pembagian tugas dalam program

1

Fungsi menerimaData()

Bertugas menerima masukan dari pengguna.

2

Fungsi hitungRataRata()

Bertugas menghitung rata-rata dari data yang tersedia.

3

Fungsi tampilkanHasil()

Bertugas menampilkan hasil pengolahan kepada pengguna.

Dengan pembagian tersebut, setiap fungsi memiliki pekerjaan yang lebih jelas. Jika suatu saat kita ingin memperbaiki cara menghitung rata-rata, kita dapat berfokus pada fungsi yang bertugas melakukan perhitungan tersebut.

Fungsi juga dapat digunakan kembali. Kita tidak harus membuat ulang fungsi yang sama setiap kali membutuhkan tugas serupa.

3. Mengenal Struktur Dasar Fungsi

Setelah memahami kegunaan fungsi, sekarang kita akan melihat bagaimana cara menuliskannya dalam C++.

Secara umum, bentuk penulisan fungsi adalah sebagai berikut:

tipe_kembalian nama_fungsi(parameter) {
    // instruksi yang dijalankan
}

Ada beberapa bagian penting dalam struktur tersebut.

Bagian	Penjelasan
tipe_kembalian	Menentukan jenis nilai yang akan dikembalikan oleh fungsi, misalnya int, double, atau void.
nama_fungsi	Nama yang digunakan untuk mengenali dan memanggil fungsi.
parameter	Variabel yang digunakan fungsi untuk menerima data dari pemanggilnya. Bagian ini dapat dikosongkan jika tidak membutuhkan parameter.
{ }	Menandai awal dan akhir blok instruksi fungsi.

Mari kita lihat contoh fungsi sederhana yang bertugas menampilkan pesan.

#include <iostream>
using namespace std;

void tampilkanPesan() {
    cout << "Selamat belajar C++!" << endl;
}

int main() {
    tampilkanPesan();

    return 0;
}

Hasil program:

Selamat belajar C++!

Pada contoh tersebut, kita membuat fungsi bernama tampilkanPesan(). Di dalamnya terdapat instruksi untuk menampilkan teks.

Perhatikan bahwa fungsi tersebut ditulis di luar main(). Setelah itu, fungsi dipanggil melalui instruksi tampilkanPesan(); di dalam main().

Ketika instruksi pemanggilan dijalankan, program akan menjalankan seluruh instruksi yang terdapat di dalam fungsi tersebut.

Perlu diingat: Mendefinisikan fungsi dan memanggil fungsi merupakan dua hal yang berbeda. Mendefinisikan berarti membuat fungsi beserta instruksinya, sedangkan memanggil berarti meminta fungsi tersebut untuk dijalankan.

4. Memahami void dan Fungsi yang Tidak Mengembalikan Nilai

Perhatikan kembali contoh sebelumnya:

void tampilkanPesan() {
    cout << "Selamat belajar C++!" << endl;
}

Ada satu kata yang mungkin menarik perhatian, yaitu void.

void merupakan tipe yang digunakan untuk menunjukkan bahwa fungsi tidak mengembalikan sebuah nilai kepada bagian program yang memanggilnya.

Artinya, fungsi tersebut dapat menjalankan instruksi, misalnya menampilkan teks, mengubah data, atau melakukan pekerjaan tertentu, tetapi tidak memberikan hasil berupa nilai melalui mekanisme return.

Contoh lainnya adalah fungsi untuk menampilkan garis pembatas.

void tampilkanGaris() {
    cout << "--------------------" << endl;
}

int main() {
    tampilkanGaris();

    cout << "HASIL PROGRAM" << endl;

    tampilkanGaris();

    return 0;
}

Hasil program:

--------------------
HASIL PROGRAM
--------------------

Fungsi tampilkanGaris() dapat dipanggil berkali-kali. Kita tidak perlu menuliskan ulang instruksi untuk mencetak garis pembatas.

Kesimpulan sementara: Gunakan void ketika fungsi bertugas menjalankan suatu pekerjaan tanpa perlu mengembalikan nilai untuk digunakan oleh bagian program lain.

5. Fungsi yang Mengembalikan Nilai dengan return

Sekarang bayangkan kita ingin membuat fungsi untuk menghitung luas persegi panjang. Berbeda dengan fungsi sebelumnya, kali ini kita tidak hanya ingin menjalankan instruksi, tetapi juga ingin mendapatkan hasil perhitungan.

Hasil tersebut nantinya dapat digunakan untuk ditampilkan, disimpan ke dalam variabel, atau diproses kembali.

Untuk melakukannya, kita dapat menggunakan return.

Perhatikan contoh berikut:

#include <iostream>
using namespace std;

int hitungLuas() {
    int panjang = 10;
    int lebar = 5;

    int luas = panjang * lebar;

    return luas;
}

int main() {
    int hasil = hitungLuas();

    cout << "Luas: " << hasil << endl;

    return 0;
}

Hasil program:

Luas: 50

Perhatikan dua bagian penting pada contoh tersebut.

int hitungLuas()

Kata int menunjukkan bahwa fungsi hitungLuas() akan mengembalikan nilai bertipe bilangan bulat.

Kemudian:

return luas;

Instruksi tersebut mengembalikan nilai yang tersimpan dalam variabel luas kepada bagian program yang memanggil fungsi.

Nilai tersebut kemudian ditampung dalam variabel hasil melalui instruksi:

int hasil = hitungLuas();

Dengan demikian, fungsi tidak hanya menjalankan pekerjaan, tetapi juga dapat menghasilkan nilai yang bisa digunakan kembali.

Memahami alur return

1

Fungsi dipanggil

Program menjalankan hitungLuas().

2

Perhitungan dilakukan

Fungsi menghitung panjang dikalikan lebar.

3

Nilai dikembalikan

Instruksi return luas; mengirimkan hasil perhitungan.

4

Hasil digunakan

Nilai yang dikembalikan disimpan ke variabel hasil.

Perlu dipahami bahwa ketika instruksi return dijalankan, fungsi tersebut langsung selesai. Instruksi lain yang berada setelah return pada jalur eksekusi yang sama tidak akan dijalankan.

Apakah return hanya dapat digunakan untuk tipe int?

Tidak. Fungsi dapat mengembalikan berbagai tipe data sesuai kebutuhan.

int ambilUmur() {
    return 17;
}

double ambilTinggi() {
    return 168.5;
}

char ambilPredikat() {
    return 'A';
}

bool apakahLulus() {
    return true;
}

Jenis nilai yang dikembalikan harus sesuai dengan tipe kembalian yang ditentukan pada deklarasi fungsi.

Materi yang berkaitan

Memahami tipe data int, double, char, dan bool

6. Menggunakan Parameter untuk Mengirimkan Data

Pada contoh sebelumnya, fungsi hitungLuas() memiliki panjang dan lebar yang ditentukan langsung di dalam fungsi.

Namun, bagaimana jika kita ingin menghitung luas beberapa persegi panjang dengan ukuran berbeda?

Apakah kita harus membuat fungsi baru setiap kali ingin menghitung ukuran yang berbeda?

Tentu tidak. Kita dapat membuat fungsi yang menerima data dari bagian program lain. Data tersebut diberikan melalui parameter.

Parameter adalah variabel yang dituliskan pada bagian tanda kurung ketika fungsi didefinisikan. Parameter digunakan untuk menerima nilai yang dikirimkan ketika fungsi dipanggil.

Mari kita ubah contoh sebelumnya.

#include <iostream>
using namespace std;

int hitungLuas(int panjang, int lebar) {
    int luas = panjang * lebar;

    return luas;
}

int main() {
    int hasil1 = hitungLuas(10, 5);
    int hasil2 = hitungLuas(8, 4);

    cout << "Luas pertama: " << hasil1 << endl;
    cout << "Luas kedua: " << hasil2 << endl;

    return 0;
}

Hasil program:

Luas pertama: 50
Luas kedua: 32

Perhatikan bagian berikut:

int hitungLuas(int panjang, int lebar)

Fungsi tersebut memiliki dua parameter, yaitu panjang dan lebar. Ketika fungsi dipanggil, program mengirimkan dua nilai untuk digunakan dalam perhitungan.

Contohnya:

hitungLuas(10, 5);

Angka 10 akan diterima oleh parameter panjang, sedangkan angka 5 akan diterima oleh parameter lebar.

Bagian	Nilai	Keterangan
Parameter panjang	10	Menerima nilai pertama.
Parameter lebar	5	Menerima nilai kedua.
Hasil perhitungan	50	Nilai panjang dikalikan lebar.

Ketika fungsi dipanggil kembali dengan angka 8 dan 4, parameter menerima nilai yang berbeda. Fungsi yang sama dapat digunakan untuk menghitung luas dengan ukuran berbeda.

Inti penggunaan parameter: Parameter membuat fungsi lebih fleksibel karena data yang diproses tidak harus ditentukan secara permanen di dalam fungsi. Kita dapat mengirimkan nilai yang berbeda setiap kali fungsi dipanggil.

Parameter dan argumen, apakah sama?

Kedua istilah ini sering digunakan ketika mempelajari fungsi. Keduanya berkaitan, tetapi memiliki pengertian yang berbeda.

Istilah	Pengertian	Contoh
Parameter	Variabel penerima data yang ditulis pada definisi fungsi.	int panjang
Argumen	Nilai atau ekspresi yang diberikan ketika fungsi dipanggil.	10

Contohnya:

int hitungLuas(int panjang, int lebar) {
    return panjang * lebar;
}

int main() {
    int hasil = hitungLuas(10, 5);
    return 0;
}

Pada contoh tersebut, panjang dan lebar adalah parameter, sedangkan angka 10 dan 5 merupakan argumen.

7. Fungsi dengan Parameter tetapi Tidak Mengembalikan Nilai

Kita sudah mempelajari fungsi yang tidak mengembalikan nilai dan fungsi yang mengembalikan nilai. Kita juga sudah mengetahui bahwa fungsi dapat menerima data melalui parameter.

Sekarang, kedua konsep tersebut dapat digabungkan.

Fungsi dapat menerima parameter tetapi tidak harus mengembalikan nilai. Contohnya adalah fungsi yang menerima nama seseorang, kemudian menampilkan pesan sapaan.

#include <iostream>
#include <string>
using namespace std;

void sapaPengguna(string nama) {
    cout << "Halo, " << nama
         << "! Selamat belajar C++." << endl;
}

int main() {
    sapaPengguna("Andi");
    sapaPengguna("Budi");

    return 0;
}

Hasil program:

Halo, Andi! Selamat belajar C++.
Halo, Budi! Selamat belajar C++.

Fungsi sapaPengguna() menerima parameter berupa string nama. Nilai nama tersebut digunakan untuk membentuk pesan yang akan ditampilkan.

Karena fungsi hanya bertugas menampilkan pesan dan tidak perlu mengembalikan hasil kepada pemanggilnya, kita menggunakan void.

Kesimpulan: Fungsi dapat memiliki parameter, mengembalikan nilai, melakukan keduanya, atau tidak memiliki keduanya. Pemilihannya bergantung pada pekerjaan yang ingin dilakukan.

8. Deklarasi Fungsi dan Function Prototype

Dalam contoh-contoh sebelumnya, fungsi selalu ditulis sebelum main(). Namun, C++ juga memungkinkan kita menuliskan fungsi setelah main(), asalkan program sudah mengenal fungsi tersebut melalui deklarasi atau function prototype.

Mengapa hal ini diperlukan?

Ketika compiler membaca kode, compiler perlu mengetahui informasi mengenai fungsi yang akan dipanggil, seperti nama fungsi, tipe kembalian, dan parameter yang digunakan.

Jika fungsi ditulis setelah main() tanpa deklarasi sebelumnya, compiler belum tentu mengenali fungsi tersebut ketika menemukan pemanggilannya.

Contoh tanpa function prototype

#include <iostream>
using namespace std;

int main() {
    int hasil = hitungJumlah(10, 5);

    cout << hasil << endl;

    return 0;
}

int hitungJumlah(int a, int b) {
    return a + b;
}

Dalam susunan tersebut, fungsi hitungJumlah() baru didefinisikan setelah main(). Ketika compiler membaca pemanggilan fungsi di dalam main(), deklarasinya belum tersedia.

Menggunakan function prototype

Untuk mengatasinya, kita dapat menambahkan deklarasi fungsi sebelum main().

#include <iostream>
using namespace std;

// Deklarasi fungsi
int hitungJumlah(int a, int b);

int main() {
    int hasil = hitungJumlah(10, 5);

    cout << "Hasil: " << hasil << endl;

    return 0;
}

// Definisi fungsi
int hitungJumlah(int a, int b) {
    return a + b;
}

Hasil program:

Hasil: 15

Perhatikan bahwa fungsi hitungJumlah() muncul dua kali, tetapi dengan tujuan berbeda.

Bagian	Tujuan
Deklarasi	Memberitahukan compiler bahwa fungsi tersedia beserta bentuk pemanggilannya.
Definisi	Menuliskan instruksi yang benar-benar dijalankan oleh fungsi.

Dengan function prototype, kita dapat menyusun fungsi setelah main() tanpa kehilangan kemampuan untuk memanggilnya dari dalam main().

Apakah nama parameter pada prototype harus sama dengan definisi fungsi?

Tidak harus. Nama parameter boleh berbeda selama tipe data, urutan, dan jumlah parameternya sesuai.

int hitungJumlah(int a, int b);

// Definisi
int hitungJumlah(int angka1, int angka2) {
    return angka1 + angka2;
}

Pada contoh tersebut, a dan b hanya digunakan pada deklarasi. Sementara itu, angka1 dan angka2 digunakan pada definisi fungsi.

9. Memahami Cara Kerja Parameter: Pass by Value

Ketika kita mengirimkan nilai ke sebuah fungsi melalui parameter biasa, C++ pada umumnya menggunakan mekanisme pass by value.

Artinya, fungsi menerima salinan nilai dari argumen yang diberikan. Jika parameter tersebut diubah di dalam fungsi, perubahan itu tidak secara langsung mengubah variabel asli yang digunakan ketika memanggil fungsi.

Mari kita lihat contohnya.

#include <iostream>
using namespace std;

void ubahNilai(int angka) {
    angka = 100;
}

int main() {
    int nilai = 50;

    ubahNilai(nilai);

    cout << "Nilai: " << nilai << endl;

    return 0;
}

Hasil program:

Nilai: 50

Mengapa hasilnya tetap 50, padahal di dalam fungsi kita mengubah angka menjadi 100?

Karena parameter angka menerima salinan dari nilai variabel nilai. Variabel angka dan nilai merupakan dua variabel yang berbeda.

Gambaran sederhana pass by value

Variabel	Sebelum fungsi	Setelah fungsi
nilai	50	50
angka	50	100

Perubahan pada parameter angka tidak mengubah variabel asli nilai.

Konsep ini penting karena kita perlu memahami apakah suatu fungsi hanya menggunakan data yang diterima atau memang dirancang untuk mengubah data milik bagian program lain.

Apakah ada cara agar fungsi dapat mengubah variabel asli?

Ada. C++ menyediakan mekanisme seperti pass by reference menggunakan tanda & pada parameter.

void ubahNilai(int &angka) {
    angka = 100;
}

Dengan reference, parameter dapat merujuk pada variabel asli. Perubahan yang dilakukan melalui parameter akan memengaruhi variabel tersebut.

Konsep reference akan lebih mudah dipahami setelah mempelajari fungsi dasar. Untuk tahap ini, cukup kenali bahwa parameter biasa dan parameter reference memiliki perilaku yang berbeda.

10. Memahami Ruang Lingkup Variabel dalam Fungsi

Ketika sebuah program mulai memiliki banyak fungsi, kita perlu memahami bahwa tidak semua variabel dapat digunakan dari setiap bagian program.

Misalnya, variabel yang dibuat di dalam sebuah fungsi pada umumnya hanya dapat digunakan di dalam blok fungsi tersebut. Variabel seperti ini disebut variabel lokal.

Perhatikan contoh berikut:

#include <iostream>
using namespace std;

void tampilkanPesan() {
    int angka = 10;

    cout << angka << endl;
}

int main() {
    tampilkanPesan();

    // cout << angka; // Tidak dapat digunakan di sini

    return 0;
}

Variabel angka dibuat di dalam fungsi tampilkanPesan(). Karena itu, variabel tersebut hanya dapat diakses di dalam ruang lingkup yang sesuai.

Variabel lokal

Variabel lokal adalah variabel yang dideklarasikan di dalam suatu fungsi atau blok tertentu. Variabel tersebut hanya dapat digunakan dalam ruang lingkup tempat ia dideklarasikan.

Variabel global

Berbeda dengan variabel lokal, variabel global dideklarasikan di luar fungsi. Variabel tersebut dapat diakses oleh fungsi-fungsi yang berada dalam ruang lingkup yang sesuai setelah deklarasinya dikenal.

#include <iostream>
using namespace std;

int angka = 100; // Variabel global

void tampilkanAngka() {
    cout << angka << endl;
}

int main() {
    tampilkanAngka();

    return 0;
}

Hasil program:

100

Walaupun variabel global dapat digunakan oleh beberapa fungsi, penggunaannya perlu dipertimbangkan dengan baik. Jika terlalu banyak bagian program mengubah variabel yang sama, kita akan lebih sulit mengetahui dari mana perubahan tersebut berasal.

Saran: Untuk program yang masih sederhana, gunakan parameter dan nilai kembalian ketika memungkinkan. Cara ini membuat hubungan antarbagian program lebih jelas dan mengurangi ketergantungan terhadap variabel global.

11. Menggabungkan Beberapa Fungsi dalam Satu Program

Sekarang kita sudah mengenal berbagai konsep fungsi: membuat fungsi, memanggil fungsi, menggunakan parameter, mengembalikan nilai, dan memahami ruang lingkup variabel.

Saatnya menggabungkan konsep-konsep tersebut ke dalam sebuah program yang lebih lengkap.

Bayangkan kita ingin membuat program untuk menghitung luas dan keliling persegi panjang. Program akan meminta panjang dan lebar, kemudian menggunakan fungsi yang berbeda untuk menghitung luas dan keliling.

Kita dapat membagi tugasnya menjadi tiga bagian:

Pembagian fungsi

1

hitungLuas()

Menerima panjang dan lebar, kemudian mengembalikan hasil perhitungan luas.

2

hitungKeliling()

Menerima panjang dan lebar, kemudian mengembalikan hasil perhitungan keliling.

3

main()

Menerima input pengguna, memanggil fungsi perhitungan, dan menampilkan hasilnya.

Berikut implementasi programnya:

#include <iostream>
using namespace std;

// Fungsi menghitung luas
int hitungLuas(int panjang, int lebar) {
    return panjang * lebar;
}

// Fungsi menghitung keliling
int hitungKeliling(int panjang, int lebar) {
    return 2 * (panjang + lebar);
}

int main() {
    int panjang, lebar;

    cout << "Masukkan panjang: ";
    cin >> panjang;

    cout << "Masukkan lebar: ";
    cin >> lebar;

    int luas = hitungLuas(panjang, lebar);
    int keliling = hitungKeliling(panjang, lebar);

    cout << "\n===== HASIL PERHITUNGAN =====\n";
    cout << "Luas: " << luas << endl;
    cout << "Keliling: " << keliling << endl;

    return 0;
}

Contoh hasil program

Masukkan panjang: 10
Masukkan lebar: 5

===== HASIL PERHITUNGAN =====
Luas: 50
Keliling: 30

Perhatikan bahwa proses perhitungan luas dan keliling tidak lagi ditulis langsung di dalam main(). Keduanya dipisahkan ke dalam fungsi masing-masing.

Fungsi main() kini lebih berfokus pada alur utama program: menerima data, meminta fungsi melakukan perhitungan, kemudian menampilkan hasilnya.

Inilah salah satu manfaat penting penggunaan fungsi. Program dapat disusun berdasarkan tanggung jawab masing-masing bagian sehingga alur utama lebih mudah dibaca.

12. Menyusun Program Pengolahan Nilai dengan Fungsi

Sekarang kita akan menggunakan contoh yang lebih dekat dengan pembahasan sebelumnya, yaitu pengolahan nilai murid menggunakan array.

Pada materi array, kita telah membuat program yang dapat menyimpan beberapa nilai, menghitung jumlah, mencari rata-rata, serta menentukan nilai tertinggi dan terendah.

Namun, jika seluruh proses tersebut ditulis dalam satu fungsi main(), kode akan menjadi cukup panjang. Kita dapat memperbaikinya dengan membagi pekerjaan ke dalam beberapa fungsi.

Dalam program ini, kita akan membuat fungsi untuk:

(- ) inputNilai() untuk menerima nilai dari pengguna.

(- ) hitungTotal() untuk menjumlahkan seluruh nilai.

(- ) cariTertinggi() untuk mencari nilai terbesar.

(- ) cariTerendah() untuk mencari nilai terkecil.

(- ) tampilkanNilai() untuk menampilkan seluruh data.

Perhatikan kode program lengkap berikut:

#include <iostream>
using namespace std;

const int JUMLAH = 5;

// Menerima input nilai
void inputNilai(int nilai[]) {
    for (int i = 0; i < JUMLAH; i++) {
        cout << "Masukkan nilai murid ke-"
             << i + 1 << ": ";

        cin >> nilai[i];
    }
}

// Menghitung jumlah seluruh nilai
int hitungTotal(int nilai[]) {
    int total = 0;

    for (int i = 0; i < JUMLAH; i++) {
        total += nilai[i];
    }

    return total;
}

// Mencari nilai tertinggi
int cariTertinggi(int nilai[]) {
    int tertinggi = nilai[0];

    for (int i = 1; i < JUMLAH; i++) {
        if (nilai[i] > tertinggi) {
            tertinggi = nilai[i];
        }
    }

    return tertinggi;
}

// Mencari nilai terendah
int cariTerendah(int nilai[]) {
    int terendah = nilai[0];

    for (int i = 1; i < JUMLAH; i++) {
        if (nilai[i] < terendah) {
            terendah = nilai[i];
        }
    }

    return terendah;
}

// Menampilkan seluruh nilai
void tampilkanNilai(int nilai[]) {
    cout << "\nDaftar nilai murid:\n";

    for (int i = 0; i < JUMLAH; i++) {
        cout << "Murid ke-" << i + 1
             << ": " << nilai[i] << endl;
    }
}

int main() {
    int nilai[JUMLAH];

    inputNilai(nilai);

    int total = hitungTotal(nilai);
    double rataRata =
        static_cast<double>(total) / JUMLAH;

    int tertinggi = cariTertinggi(nilai);
    int terendah = cariTerendah(nilai);

    tampilkanNilai(nilai);

    cout << "\n===== HASIL PENGOLAHAN =====\n";
    cout << "Jumlah nilai: " << total << endl;
    cout << "Rata-rata: " << rataRata << endl;
    cout << "Nilai tertinggi: " << tertinggi << endl;
    cout << "Nilai terendah: " << terendah << endl;

    return 0;
}

Contoh hasil program

Masukkan nilai murid ke-1: 80
Masukkan nilai murid ke-2: 85
Masukkan nilai murid ke-3: 90
Masukkan nilai murid ke-4: 75
Masukkan nilai murid ke-5: 95

Daftar nilai murid:
Murid ke-1: 80
Murid ke-2: 85
Murid ke-3: 90
Murid ke-4: 75
Murid ke-5: 95

===== HASIL PENGOLAHAN =====
Jumlah nilai: 425
Rata-rata: 85
Nilai tertinggi: 95
Nilai terendah: 75

Mengapa program tersebut lebih terstruktur?

Jika diperhatikan, setiap fungsi memiliki satu tanggung jawab yang jelas. Fungsi untuk menghitung total tidak perlu mengetahui bagaimana data dimasukkan. Fungsi untuk mencari nilai tertinggi juga tidak perlu mengetahui bagaimana hasil akan ditampilkan.

Setiap fungsi cukup menerima data yang dibutuhkan, menjalankan tugasnya, kemudian mengembalikan hasil jika diperlukan.

Fungsi	Tanggung jawab	Hasil
inputNilai()	Menerima data	Mengisi array
hitungTotal()	Menjumlahkan nilai	int
cariTertinggi()	Mencari nilai terbesar	int
cariTerendah()	Mencari nilai terkecil	int
tampilkanNilai()	Menampilkan data	void

Perhatikan juga bahwa array dapat digunakan sebagai parameter fungsi. Dengan demikian, data yang disimpan dalam array dapat diproses oleh fungsi yang berbeda tanpa harus menulis ulang seluruh isi array.

Catatan teknis: Pada contoh ini, array bertipe int diteruskan sebagai parameter fungsi. Untuk array bawaan seperti ini, parameter fungsi menerima akses ke elemen-elemen array yang sama, bukan membuat salinan seluruh array. Karena itu, perubahan elemen melalui fungsi dapat memengaruhi array yang digunakan pemanggil.

13. Kesalahan yang Sering Terjadi Saat Menggunakan Fungsi

Ketika mulai membuat fungsi sendiri, ada beberapa kesalahan yang perlu diperhatikan. Kesalahan ini dapat menyebabkan program gagal dikompilasi atau menghasilkan perilaku yang tidak sesuai harapan.

1. Memanggil fungsi dengan nama yang salah

void tampilkanPesan() {
    cout << "Halo!";
}

int main() {
    tampilkanPesan1(); // Salah
    return 0;
}

Nama fungsi yang dipanggil harus sesuai dengan nama fungsi yang didefinisikan atau dideklarasikan.

2. Jumlah atau tipe argumen tidak sesuai

int tambah(int a, int b) {
    return a + b;
}

int main() {
    int hasil = tambah(10); // Salah
    return 0;
}

Fungsi tersebut membutuhkan dua argumen, tetapi pemanggilannya hanya memberikan satu.

3. Tipe nilai kembalian tidak sesuai

int hitungLuas() {
    return 10.5;
}

Fungsi dideklarasikan mengembalikan int, tetapi nilai yang diberikan adalah bilangan pecahan. C++ dapat melakukan konversi tertentu, tetapi bagian desimal akan hilang. Jika ingin mempertahankan nilai pecahan, gunakan tipe double.

4. Lupa menuliskan return

int hitungJumlah(int a, int b) {
    int hasil = a + b;
}

Fungsi bertipe int seharusnya mengembalikan nilai. Kita perlu menambahkan return hasil;.

5. Menggunakan variabel lokal di luar ruang lingkupnya

void prosesData() {
    int hasil = 100;
}

int main() {
    cout << hasil; // Salah
    return 0;
}

Variabel hasil hanya dikenal di dalam fungsi prosesData(). Jika ingin menggunakan nilainya di bagian lain, kita dapat mengembalikannya melalui return atau menggunakan mekanisme parameter yang sesuai.

14. Latihan Pemahaman

Setelah mempelajari fungsi, cobalah menjawab pertanyaan dan mengerjakan latihan berikut. Tujuannya bukan hanya menghafal bentuk penulisan fungsi, tetapi memahami bagaimana fungsi bekerja dalam sebuah program.

Latihan 1 — Mengenali struktur fungsi

Perhatikan kode berikut:

int hitungJumlah(int a, int b) {
    return a + b;
}

(- ) Apa nama fungsi tersebut?

(- ) Apa tipe nilai yang dikembalikan?

(- ) Berapa jumlah parameternya?

(- ) Apa fungsi dari instruksi return?

Latihan 2 — Membuat fungsi void

Buatlah fungsi bernama tampilkanNama() yang bertugas menampilkan nama kamu di layar.

Panggil fungsi tersebut dari dalam main().

Latihan 3 — Menghitung luas segitiga

Buat fungsi bernama hitungLuasSegitiga() yang menerima parameter alas dan tinggi, kemudian mengembalikan hasil perhitungan luas segitiga.

Gunakan rumus:

Luas = (alas × tinggi) / 2

Latihan 4 — Menggunakan function prototype

Buat program yang memiliki fungsi hitungKuadrat(). Tuliskan deklarasi fungsi sebelum main(), kemudian definisi fungsi setelah main().

Fungsi tersebut menerima satu bilangan dan mengembalikan hasil kuadratnya.

Latihan 5 — Menggabungkan beberapa fungsi

Buat program sederhana untuk menghitung luas dan keliling persegi.

Ketentuan:

(- ) Program meminta pengguna memasukkan panjang sisi persegi.

(- ) Buat fungsi untuk menghitung luas persegi.

(- ) Buat fungsi untuk menghitung keliling persegi.

(- ) Kedua fungsi mengembalikan hasil perhitungan.

(- ) Tampilkan hasilnya melalui main().

Petunjuk mengerjakan latihan

Untuk latihan membuat fungsi yang mengembalikan nilai, tentukan terlebih dahulu tipe data yang sesuai. Jika hasil berupa bilangan bulat, kita dapat menggunakan int. Jika membutuhkan hasil pecahan, gunakan double.

Jangan lupa menentukan parameter yang diperlukan. Setelah itu, tuliskan instruksi perhitungan dan kembalikan hasilnya menggunakan return.

15. Tantangan: Membuat Program Kalkulator Sederhana dengan Fungsi

Sebagai tantangan akhir, cobalah membuat program kalkulator sederhana. Program harus dapat melakukan beberapa operasi matematika dengan bantuan fungsi yang berbeda.

Ketentuan program

(- ) Program menerima dua bilangan dari pengguna.

(- ) Program menyediakan operasi penjumlahan.

(- ) Program menyediakan operasi pengurangan.

(- ) Program menyediakan operasi perkalian.

(- ) Program menyediakan operasi pembagian.

(- ) Setiap operasi dibuat dalam fungsi tersendiri.

(- ) Hasil operasi ditampilkan melalui main().

(- ) Program harus menangani pembagian dengan nol.

Misalnya, kamu dapat membuat fungsi seperti berikut:

double tambah(double a, double b);
double kurang(double a, double b);
double kali(double a, double b);
double bagi(double a, double b);

Setiap fungsi memiliki tugas berbeda, tetapi seluruhnya menerima dua bilangan sebagai parameter dan mengembalikan hasil perhitungan.

Untuk pembagian, pastikan program memeriksa apakah bilangan pembagi bernilai nol sebelum melakukan operasi.

Petunjuk tambahan untuk tantangan

Gunakan percabangan if atau switch untuk menentukan operasi yang dipilih pengguna.

Untuk fungsi pembagian, salah satu cara sederhana adalah memeriksa nilai pembagi sebelum melakukan perhitungan. Jika pembagi bernilai nol, tampilkan pesan kesalahan dan jangan melakukan pembagian.

Jika sudah berhasil, coba kembangkan program dengan menu yang memungkinkan pengguna melakukan beberapa perhitungan tanpa harus menjalankan ulang program.

16. Penutup

Menyusun program menjadi bagian-bagian yang terstruktur

Fungsi merupakan salah satu konsep penting dalam pemrograman C++. Dengan fungsi, kita dapat membagi program menjadi beberapa bagian yang memiliki tugas masing-masing.

Kita dapat membuat fungsi yang hanya menjalankan instruksi menggunakan void, maupun fungsi yang mengembalikan nilai menggunakan return. Fungsi juga dapat menerima data melalui parameter sehingga dapat digunakan kembali dengan nilai yang berbeda.

Selain itu, kita telah mempelajari deklarasi fungsi, function prototype, pass by value, dan ruang lingkup variabel. Seluruh konsep tersebut membantu kita memahami bagaimana fungsi berinteraksi dengan bagian lain dalam program.

Semakin banyak fungsi yang digunakan dengan pembagian tugas yang tepat, semakin mudah sebuah program dikembangkan dan dipelihara.

Sampai di sini, kita telah mempelajari cara menyusun program menggunakan fungsi. Namun, fungsi bukan satu-satunya cara untuk mengorganisasi kode. Ketika program semakin besar, kita juga membutuhkan cara untuk mengelompokkan data dan fungsi yang saling berkaitan.

Pada materi berikutnya, kita akan mulai mengenal konsep pemrograman berorientasi objek atau Object-Oriented Programming (OOP), yang memungkinkan kita menyusun program berdasarkan objek, atribut, dan perilakunya.

Lanjutkan perjalanan belajar C++

Materi berikutnya: Mengenal Pemrograman Berorientasi Objek (OOP) →

---

Materi sebelumnya

Mengelola Banyak Data dengan Array
Mengulang Instruksi dengan Perulangan
Membuat Program yang Dapat Mengambil Keputusan