Chapter lalu kita membuktikan bahwa pass-by-value memberi fungsi salinan data sehingga pemanggil tetap utuh. Kini kita ambil kendali penuh: pass by reference, mekanisme yang membuat parameter menjadi alias — nama lain — untuk variabel asli milik pemanggil. Sintaksnya hanya satu tanda & pada deklarasi parameter, tetapi dampaknya besar: fungsi kini benar-benar bisa mengubah data pemanggil, membuka pola desain baru seperti parameter keluaran. Kita akan mengulang eksperimen yang sama dengan Chapter Pass by Value, kali ini dengan &, lalu membahas pola out parameter dan kapan cara ini layak dipakai.

Tanda &: Parameter Menjadi Alias #

Program berikut sama persis dengan eksperimen pass-by-value pada Chapter sebelumnya — hanya deklarasi parameternya yang diberi tanda &. Bandingkan kedua outputnya:

cpp 
#include <iostream>
#include <string>

void ubahAngka(int& x) {          // tanda & : parameter reference
    x = x * 100;
    std::cout << "Di dalam ubahAngka : " << x << "\n";
}

void ubahTeks(std::string& teks) {
    teks = teks + " (sudah diedit)";
    std::cout << "Di dalam ubahTeks  : " << teks << "\n";
}

int main() {
    int angka = 7;
    std::string teks = "pesan";

    ubahAngka(angka);
    ubahTeks(teks);

    std::cout << "Setelah pemanggilan: angka = " << angka << "\n";
    std::cout << "Setelah pemanggilan: teks  = " << teks << "\n";
    return 0;
}

Output yang Dihasilkan:

text 
Di dalam ubahAngka : 700
Di dalam ubahTeks  : pesan (sudah diedit)
Setelah pemanggilan: angka = 700
Setelah pemanggilan: teks  = pesan (sudah diedit)

Dua baris terakhir inilah bedanya: kali ini angka benar-benar berubah menjadi 700 dan teks menjadi "pesan (sudah diedit)". Penyebabnya, parameter int& x tidak menampung salinan — ia adalah nama lain yang menunjuk ke variabel angka yang sama di memori. Operasi x = x * 100 kini berarti “kalikan angka milik main() dengan 100”. Reference tidak punya data sendiri; setiap baca dan tulis pada alias adalah baca dan tulis pada aslinya. Pertanyaan wajar berikutnya: bila argumennya literal seperti ubahAngka(7), pemetaan gagal — reference int& non-const menuntut variabel yang benar-benar ada, dan compiler menolaknya.

Parameter Keluaran (Out Parameter) #

Dengan reference, parameter tidak lagi hanya pintu masuk — ia bisa menjadi pintu keluar. Pola ini disebut out parameter: fungsi menulis hasilnya ke parameter reference yang disiapkan pemanggil. Berikut dua contoh klasiknya:

cpp 
#include <iostream>

// Dua hasil sekaligus lewat parameter keluaran (out parameter)
void bagiDenganSisa(int pembilang, int penyebut, int& hasil, int& sisa) {
    hasil = pembilang / penyebut;
    sisa = pembilang % penyebut;
}

// Pola klasik: menukar isi dua variabel
void tukar(int& a, int& b) {
    int sementara = a;
    a = b;
    b = sementara;
}

int main() {
    int hasil = 0;
    int sisa = 0;
    bagiDenganSisa(47, 5, hasil, sisa);
    std::cout << "47 / 5 = " << hasil << " sisa " << sisa << "\n";

    int kiri = 10;
    int kanan = 90;
    tukar(kiri, kanan);
    std::cout << "Setelah tukar: kiri = " << kiri
              << ", kanan = " << kanan << "\n";
    return 0;
}

Output yang Dihasilkan:

text 
47 / 5 = 9 sisa 2
Setelah tukar: kiri = 90, kanan = 10

Fungsi bagiDenganSisa menghasilkan DUA nilai sekaligus — hasil bagi dan sisa — sesuatu yang mustahil dilakukan dengan satu return. Pemanggil menyiapkan dua variabel penampung, lalu fungsi mengisinya lewat reference. Sementara tukar adalah contoh paling terkenal dari pola ini: dua variabel saling bertukar isi lewat perantara sementara, dan perubahan itu langsung terlihat di main(). Fungsi std::swap di standard library bekerja persis dengan prinsip ini. Kedua fungsi juga menunjukkan pembagian peran parameter yang sehat: pembilang dan penyebut adalah in parameter (hanya dibaca), sedangkan hasil dan sisa adalah out parameter (ditulis fungsi).

Kapan Memakai Pass by Reference #

Pass by reference bukan pengganti pass by value, melainkan alat untuk kebutuhan tertentu:

  • Fungsi harus mengubah data pemanggil: penukaran nilai, penambahan elemen, perapian data — tanpa & semua usaha itu tidak akan sampai.
  • Lebih dari satu nilai keluaran: out parameter mengantar beberapa hasil sekaligus; sebagai pembanding, struct yang bisa menampung banyak nilai dalam satu return kita bahas pada Section Struktur dan Tipe Data Komposit.
  • Data besar yang juga ingin diubah: tidak ada salinan yang dilakukan, jadi pemanggilan tetap murah meski datanya jutaan elemen.

Rujukan resmi tentang reference ada di cppreference: reference declaration . Berikutnya kita menyempurnakan resepnya: menggabungkan kehematan reference dengan keamanan pass by value dalam satu kata kunci const&.