Reference vs pointer C++: kapan memakai masing-masing

Dua cara merujuk sesuatu

Kamu sudah mengenal pointer: variabel yang menyimpan alamat dan memungkinkan kamu menjangkau objek yang tinggal di sana. Reference adalah alat lain yang diberikan C++ untuk bekerja secara tidak langsung dengan objek yang sudah ada. Keduanya cukup mirip sampai pemula sering bingung harus memilih yang mana, jadi halaman ini membandingkan keduanya berdampingan.

Versi singkatnya: reference adalah alias. Begitu int& r = x; dijalankan, r adalah x: objek yang sama, nama yang berbeda. Pointer adalah objek terpisah yang kebetulan menyimpan alamat objek lain. Satu perbedaan itu menentukan semua hal lainnya.

Reference adalah alias

Reference harus diikat ke sebuah objek saat dibuat, dan sejak itu setiap pemakaian reference menyentuh objek aslinya.

#include <iostream>
using namespace std;

int main() {
    int score = 10;
    int& alias = score;   // alias and score are now the same object

    alias = 42;           // writes through to score
    cout << score << endl; // 42

    score = 7;
    cout << alias << endl; // 7 - they move together
    return 0;
}

Perhatikan bahwa tidak ada * untuk dereference dan tidak ada & untuk "mengambil alamat" di tempat pemakaiannya. Kamu membaca dan menulis alias persis seperti int biasa. & pada int& alias adalah bagian dari tipe, bukan operator address-of.

Di mana perbedaannya

Perilaku di bawah ini adalah alasan kedua alat itu ada. Inilah tabel yang perlu kamu hafal.

//                      reference            pointer
// must be initialized? yes                  no (but should be)
// can be null?         no                   yes (nullptr)
// can be reseated?     no                   yes
// pointer arithmetic?  no                   yes
// syntax to use it     just the name        *p  or  p->member
// taking address       &ref == &original    &p is the pointer's own address

Dua di antaranya paling sering menjebak. Pertama, reference tidak pernah bisa diarahkan ulang. Mengisi nilai ke reference berarti menyalin nilai ke dalam objek yang dirujuknya, bukan mengarahkan reference itu ke sesuatu yang baru.

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int& r = a;

    r = b;   // does NOT make r refer to b - it copies b's value INTO a
    cout << a << endl; // 2  (a was changed)
    cout << b << endl; // 2

    b = 99;
    cout << r << endl; // 2  (r still aliases a, not b)
    return 0;
}

Sebaliknya, pointer bebas menunjuk ke tempat lain kapan saja:

#include <iostream>
using namespace std;

int main() {
    int a = 1, b = 2;
    int* p = &a;

    p = &b;   // reseats: p now points at b
    *p = 99;  // writes to b
    cout << a << endl; // 1
    cout << b << endl; // 99
    return 0;
}

Kedua, reference tidak pernah boleh null, sedangkan pointer bisa. Itu artinya "tidak ada nilai" bisa dinyatakan dengan pointer tapi tidak dengan reference, sifat yang akan sangat sering kamu andalkan.

Memilih untuk parameter fungsi

Di sinilah pilihan itu paling sering muncul. Saat sebuah fungsi perlu membaca atau mengubah objek milik pemanggilnya, keduanya bisa dipakai, tapi masing-masing menyampaikan maksud yang berbeda.

#include <iostream>
using namespace std;

// reference: the argument ALWAYS exists; cleaner call site
void addTax(double& price) {
    price *= 1.2;
}

// pointer: the argument is OPTIONAL; nullptr means "skip"
void applyDiscount(double* price) {
    if (price == nullptr) return;   // caller can opt out
    *price *= 0.9;
}

int main() {
    double cart = 100.0;

    addTax(cart);              // no &, reads like a normal call
    cout << cart << endl;      // 120

    applyDiscount(&cart);      // explicit & flags "this may be modified"
    cout << cart << endl;      // 108

    applyDiscount(nullptr);    // legal: nothing happens
    return 0;
}

Versi reference (addTax(cart)) tidak mungkin dipanggil dengan "tidak ada apa-apa", jadi di dalam fungsi kamu tidak perlu mengecek null: objeknya dijamin ada. Versi pointer (applyDiscount(&cart)) menunjukkan di tempat pemanggilan, lewat &, bahwa argumennya mungkin diubah, dan memungkinkan pemanggil mengirim nullptr yang berarti "tidak berlaku". Pilih yang jaminannya cocok dengan fungsimu.

Untuk parameter baca saja yang tipenya besar, pilihan yang lazim adalah const T&: cara ini menghindari penyalinan dan berjanji tidak akan mengubah apa pun. Lihat halaman parameter fungsi untuk pembahasan lebih lanjut tentang pass by value vs pass by reference.

Aturan praktis sederhana

Kalau ragu, pakai reference sebagai default dan baru beralih ke pointer saat kamu butuh kemampuan yang tidak dimiliki reference:

• Pakai reference kalau objeknya selalu ada dan identitasnya tidak pernah berubah. Ini kasus umum untuk parameter fungsi dan alias.
• Pakai pointer kalau salah satu hal ini benar:
  • "Tidak ada apa-apa" adalah keadaan yang sah (argumen opsional, pencarian yang mungkin tidak menemukan hasil): pointer bisa bernilai nullptr.
  • Kamu perlu menunjuk ke objek yang berbeda seiring waktu: pointer bisa diarahkan ulang.
  • Kamu mengelola memori heap yang nanti akan di-delete (atau, lebih baik lagi, smart pointer), atau menelusuri array dengan aritmatika pointer.

Kalau tidak ada yang berlaku, reference adalah pilihan yang lebih bersih dan aman, karena compiler memastikan "selalu sah, tidak pernah diarahkan ulang" untukmu.

Kesalahan umum yang perlu dihindari

• Mengira ref = other akan mengarahkan ulang. Pernyataan itu justru mengisi nilai ke objek yang dirujuk. Reference terikat seumur hidup; kalau kamu butuh pengarahan ulang, pakai pointer.
• Mengembalikan reference (atau pointer) ke variabel lokal. int& f() { int x = 5; return x; } mengembalikan dangling reference: x mati saat f selesai, dan memakai hasilnya adalah undefined behavior. Jebakan yang sama berlaku untuk pointer (return &x;).
• Memalsukan "reference null". Menulis int& r = *p; saat p bernilai nullptr adalah undefined behavior begitu dereference terjadi, bukan reference "kosong" yang aman. Nyatakan sifat opsional dengan pointer atau std::optional.
• Memakai pointer karena kebiasaan. Kalau argumennya selalu ada dan tidak akan pernah diarahkan ulang, reference menghilangkan seluruh jenis pengecekan null dan crash. Jangan membayar kemampuan yang tidak kamu pakai.

Berikutnya: memori dinamis

Sejauh ini setiap objek yang kamu rujuk atau tunjuk dibuat secara otomatis di stack. Halaman berikutnya, memori dinamis, membahas new dan delete: meminta memori ke sistem operasi saat runtime, kenapa pointer (bukan reference) yang memilikinya, dan bagaimana lupa membebaskannya menyebabkan memory leak.