Reference C++: pass by reference, const&, dan alias

Nama lain untuk hal yang sama

Di halaman parameter fungsi, setiap argumen disalin ke dalam fungsi. Penyalinan itulah alasan fungsi tidak bisa mengubah variabel milik pemanggil: ia hanya pernah melihat duplikatnya sendiri. Reference menembus batas itu. Reference adalah alias: nama kedua yang diikat ke variabel yang sudah ada, dan memakai memori yang persis sama.

Kamu membuat reference dengan & di deklarasi. Begitu terikat, reference dan variabel aslinya tidak bisa dibedakan:

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias is another name for score

    alias = 99;           // writes through to score
    cout << score << "\n"; // 99
    cout << alias << "\n"; // 99

    score = 5;
    cout << alias << "\n"; // 5 - they are the same object
}

Dua aturan membuat reference aman dan bisa ditebak: reference harus diinisialisasi saat dideklarasikan (int& r; adalah error kompilasi), dan setelahnya tidak pernah bisa diarahkan ulang ke hal lain. Mengisi nilai ke reference selalu menulis ke variabel yang diikatnya sejak awal.

Pass by reference: biarkan fungsi menjangkau balik

Manfaat sesungguhnya ada di fungsi. Tambahkan & pada sebuah parameter, maka fungsi menerima alias ke argumen milik pemanggil, bukan salinannya. Sekarang perubahan di dalam fungsi terlihat dari luar:

#include <iostream>
using namespace std;

void addBonus(int& points) {   // & means "the caller's variable, not a copy"
    points += 50;
}

int main() {
    int total = 100;
    addBonus(total);
    cout << total << "\n";   // 150 - the original was changed
}

Hapus &, maka addBonus hanya akan menaikkan salinan sekali pakai, dan total tetap 100. Satu karakter itu adalah seluruh perbedaannya. Inilah cara standar untuk menulis fungsi yang menghasilkan lebih dari satu hasil atau mengubah input-nya di tempat. Contoh klasiknya adalah menukar dua variabel:

#include <iostream>
using namespace std;

void swapValues(int& a, int& b) {
    int tmp = a;
    a = b;
    b = tmp;
}

int main() {
    int x = 1, y = 2;
    swapValues(x, y);
    cout << x << " " << y << "\n";   // 2 1
}

Tanpa reference, swapValues hanya akan menukar salinan lokal dan x/y tetap 1 2. (Library standar sudah punya std::swap, tapi menulisnya sendiri menunjukkan dengan jelas apa yang kamu dapat dari parameter reference.)

const reference: baca dengan cepat, janji tidak menyentuh

Pass by reference juga menghindari penyalinan, dan untuk objek besar penyalinan itu bisa mahal. Tapi parameter T& biasa memberi sinyal "aku mungkin mengubah ini", dan itu menyesatkan kalau kamu hanya ingin membaca. Solusinya adalah const T&: kamu mendapat kecepatan reference tanpa penyalinan dan janji yang dipastikan compiler bahwa fungsi tidak akan mengubah argumennya.

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

// No copy of the string is made, and we can't accidentally modify it.
void greet(const string& name) {
    cout << "Hello, " << name << "! (" << name.size() << " chars)\n";
    // name = "x";  // would be a compile error - name is const
}

int main() {
    string user = "Ada Lovelace";
    greet(user);
    greet("literal works too");   // const& can also bind to a temporary
}

Reference non-const hanya bisa diikat ke variabel yang bisa diubah, tapi reference const juga bisa diikat ke literal dan objek sementara. Itulah sebabnya greet("literal works too") bisa dikompilasi. Aturan praktis untuk memilih tipe parameter:

void f(int x)              // cheap type, read-only -> just copy it
void f(const string& s)   // heavy type, read-only -> const reference
void f(string& s)         // you intend to modify the caller's object

Gunakan const T& sebagai default untuk tipe class apa pun yang hanya kamu baca (string, vector, struct buatanmu sendiri), dan simpan reference non-const untuk saat kamu memang ingin menulis balik.

Mengembalikan reference

Fungsi juga bisa mengembalikan reference, memberi pemanggil alias ke sesuatu yang sudah ada. Ini umum di kode yang mirip container: inilah yang membuat v[i] = 5 bisa bekerja, dan inilah yang dilakukan operator overloading di balik layar:

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

// Returns an alias to an element, so the caller can assign to it.
int& at(vector<int>& v, size_t i) {
    return v[i];
}

int main() {
    vector<int> data = {1, 2, 3};
    at(data, 1) = 42;            // assign through the returned reference
    cout << data[1] << "\n";     // 42
}

Karena at mengembalikan int&, ekspresi pemanggilan at(data, 1) itu sendiri adalah lvalue yang bisa diisi nilai. Kalau yang dikembalikan int biasa, at(data, 1) = 42 tidak akan bisa dikompilasi, karena kamu akan mengisi nilai ke salinan sementara.

Jebakan besar: dangling reference

Reference tidak memiliki apa pun; ia hanya menunjuk ke memori yang tinggal di tempat lain. Kalau memori itu mati saat reference masih dipakai, kamu punya dangling reference, dan membaca lewat reference itu adalah undefined behavior. Program bisa mencetak nilai sampah, crash, atau kelihatan berjalan sampai akhirnya merusak harimu di production. Kesalahan klasiknya adalah mengembalikan reference ke variabel lokal:

int& broken() {
    int local = 42;
    return local;   // BUG: local is destroyed when broken() returns
}                   // the returned reference dangles

int main() {
    int& r = broken();
    cout << r << "\n";   // UNDEFINED BEHAVIOR - reads dead memory
}

Variabel lokal local hilang begitu broken selesai, jadi reference-nya menunjuk ke ruang stack yang sudah diambil kembali. Kembalikan reference hanya ke sesuatu yang hidup lebih lama daripada pemanggilannya: parameter yang dikirim sebagai reference, data member, atau variabel static. Kalau nilainya dihitung di dalam fungsi, kembalikan berdasarkan nilai dan biarkan compiler mengoptimalkan penyalinannya. Jebakan yang sama berlaku untuk perulangan berbasis range dan setiap reference yang diikat ke objek sementara: jangan pernah menyimpan reference melewati masa hidup hal yang dirujuknya.

Berikutnya: function overloading

Reference memberimu pengaturan kedua di setiap parameter (salinan atau alias, bisa diubah atau const), dan pengaturan itu berhubungan langsung dengan topik berikutnya. Selanjutnya, function overloading memungkinkan kamu mendefinisikan beberapa fungsi dengan nama yang sama tapi daftar parameter yang berbeda, dan compiler memilih yang tepat dengan mencocokkan tipe argumennya, termasuk apakah argumen itu dikirim berdasarkan nilai, reference, atau reference const.