Parameter Fungsi C++: Pass by Value, Reference, Const

Parameter vs Argumen

Parameter sebuah fungsi adalah variabel bernama di definisinya; argumen adalah nilai sebenarnya yang kamu berikan saat memanggilnya. Halaman sebelumnya menunjukkan cara mendefinisikan dan memanggil fungsi. Halaman ini membahas bagaimana nilai-nilai itu benar-benar masuk, karena C++ menyediakan beberapa cara dan pilihanmu memengaruhi kebenaran sekaligus kecepatan program.

Default di C++ adalah pass by value: fungsi menerima sebuah salinan.

#include <iostream>
using namespace std;

void addTen(int n) {   // n is a copy of whatever you pass
    n = n + 10;
    cout << "inside: " << n << endl;
}

int main() {
    int score = 5;
    addTen(score);
    cout << "outside: " << score << endl;   // still 5
    return 0;
}

Di dalam addTen, n adalah variabel terpisah yang diinisialisasi dari score. Mengisi ulang n hanya menyentuh salinan itu, jadi score di main tetap utuh. Cara ini aman dan bisa ditebak: fungsi tidak bisa tidak sengaja merusak datamu, dan justru karena itulah cara ini menjadi default.

Pass by Reference: Membiarkan Fungsi Mengubah Milik Pemanggil

Kadang kamu ingin fungsi mengubah variabel milik pemanggil. Tambahkan & pada tipe parameternya, dan parameter itu menjadi referensi: alias untuk variabel aslinya, bukan salinan:

#include <iostream>
using namespace std;

void addTen(int& n) {   // n refers to the caller's variable
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15 - the original changed
    return 0;
}

Satu-satunya perbedaan dari contoh pertama adalah &, tetapi sekarang n dan score adalah objek yang sama. Ini cara standar untuk "mengembalikan" lebih dari satu nilai atau memperbarui sesuatu di tempat. Pemakaian 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 << endl;   // 2 1
    return 0;
}

Tanpa &, swapValues akan menukar dua salinan dan main tidak akan melihat perubahan apa pun. Ini bug pemula yang sangat umum.

Referensi Const: Akses Read-Only yang Murah

Pass by value menyalin argumen. Untuk int biayanya nol, tetapi menyalin string atau vector yang besar di setiap pemanggilan adalah kerja sia-sia yang nyata. Solusinya adalah referensi const (const T&): kamu mendapat kecepatan referensi (tanpa salinan) plus janji yang ditegakkan compiler bahwa argumen tidak akan diubah.

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

// no copy of the string is made, and we can't accidentally change it
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // would be a compile error - name is const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& can also bind to a temporary
    return 0;
}

Patokan yang praktis: kirim tipe bawaan yang kecil (int, double, char, bool, pointer) by value, dan kirim objek besar yang hanya perlu kamu baca lewat referensi const. Simpan T& non-const biasa untuk kasus ketika kamu memang berniat mengubah objek milik pemanggil.

Jebakan yang halus: int& n biasa tidak bisa mengikat nilai sementara atau literal. addTen(5) dari contoh pertama akan gagal dikompilasi kalau parameternya int&, karena 5 bukan variabel yang bisa dijadikan alias. const int& bisa mengikat 5, satu alasan lagi kenapa referensi const begitu banyak dipakai.

Argumen Default

Kamu bisa memberi parameter nilai cadangan sehingga pemanggil boleh tidak menuliskannya. Kalau argumennya tidak ada, nilai default yang dipakai:

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

void connect(const string& host, int port = 8080, bool secure = false) {
    cout << (secure ? "https" : "http") << "://"
         << host << ":" << port << endl;
}

int main() {
    connect("example.com");              // port=8080, secure=false
    connect("example.com", 443);         // secure=false
    connect("example.com", 443, true);   // all three given
    return 0;
}

Dua aturan sering menjebak. Pertama, nilai default harus berada di belakang: begitu satu parameter punya nilai default, setiap parameter sesudahnya juga harus punya. Kamu tidak bisa menulis void f(int a = 1, int b) karena tidak ada cara memberikan b sambil melewati a. Kedua, kalau fungsi dideklarasikan di header dan didefinisikan di tempat lain, tulis nilai default hanya di deklarasi, jangan pernah mengulangnya di definisi, karena mengulangnya adalah compile error.

Mengirim Array dan Vector

Array mentah meluruh menjadi pointer saat dikirim, sehingga fungsi kehilangan informasi ukurannya. Kamu hampir selalu mengirim panjangnya bersama array itu:

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // arr is really an int* here
    int total = 0;
    for (int i = 0; i < size; i++) total += arr[i];
    return total;
}

int main() {
    int nums[] = {4, 8, 15, 16};
    cout << sum(nums, 4) << endl;   // 43
    return 0;
}

Karena array berubah menjadi pointer, sizeof(arr) di dalam sum akan memberikan ukuran pointer, bukan ukuran array. Ini bug yang terkenal. Di C++ modern, utamakan std::vector (atau std::span di C++20) yang dikirim lewat referensi const, yang membawa ukurannya sendiri:

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

int sum(const vector<int>& v) {   // no copy, knows its own size
    int total = 0;
    for (int x : v) total += x;
    return total;
}

int main() {
    vector<int> nums = {4, 8, 15, 16};
    cout << sum(nums) << endl;   // 43
    return 0;
}

Perhatikan const&-nya: hilangkan itu, dan setiap pemanggilan menyalin seluruh vector. Untuk vector berisi empat elemen itu tidak masalah, tetapi untuk sejuta elemen itu jadi penguras performa yang diam-diam.

Parameter Pointer

Kamu juga bisa mengirim pointer (T*). Seperti referensi, ini membuat fungsi bisa menjangkau data milik pemanggil, tetapi pointer bisa diarahkan ulang atau bernilai null. Karena itu pointer adalah alat yang tepat saat "tidak ada nilai" adalah pilihan yang sah:

#include <iostream>
using namespace std;

// returns false when there's nowhere to write the result
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // guard against null
    *out = 0.0;
    for (const char* p = text; *p >= '0' && *p <= '9'; ++p) {
        *out = *out * 10 + (*p - '0');
    }
    return true;
}

int main() {
    double value;
    if (tryParseDouble("123", &value)) {
        cout << "parsed: " << value << endl;
    }
    return 0;
}

Pemanggil mengirim &value untuk berbagi alamatnya, dan fungsi menulis lewat *out. Perbedaan utamanya dari referensi: pointer bisa bernilai nullptr, jadi fungsi yang menerimanya sebaiknya mengecek dulu sebelum melakukan dereference. Melewatkan pengecekan itu lalu melakukan dereference pada null pointer adalah undefined behavior, biasanya berakhir crash. Kalau "tidak ada nilai" tidak pernah masuk akal, referensi lebih rapi karena sejak awal ia tidak bisa null.

Berikutnya: Referensi

Parameter adalah tempat referensi paling terasa manfaatnya, tetapi referensi adalah fitur tersendiri: alias yang bisa kamu buat untuk variabel apa pun, tidak hanya di dalam signature fungsi. Halaman berikutnya membahas cara kerja referensi secara mandiri: cara mendeklarasikannya, kenapa ia harus langsung diinisialisasi, perbedaan antara lvalue reference dan referensi const, serta cara-cara halus sebuah referensi bisa berakhir dangling.