Parametry funkcji w C++: przez wartość, przez referencję i const

Parametry a argumenty

Parametry funkcji to nazwane zmienne w jej definicji; argumenty to rzeczywiste wartości, które przekazujesz przy wywołaniu. Poprzednia strona pokazała, jak definiować i wywoływać funkcje. Ta strona dotyczy tego, jak te wartości właściwie trafiają do środka, bo C++ daje kilka sposobów, a wybór wpływa zarówno na poprawność, jak i na szybkość.

Domyślnie C++ stosuje przekazywanie przez wartość: funkcja dostaje kopię.

#include <iostream>
using namespace std;

void addTen(int n) {   // n to kopia tego, co przekażesz
    n = n + 10;
    cout << "inside: " << n << endl;
}

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

Wewnątrz addTen n to osobna zmienna zainicjalizowana wartością score. Ponowne przypisanie do n dotyka tylko tej kopii, więc score w main pozostaje nietknięte. To bezpieczne i przewidywalne (funkcja nie może przypadkiem nadpisać twoich danych) i właśnie dlatego jest to zachowanie domyślne.

Przekazywanie przez referencję: funkcja zmienia dane wywołującego

Czasem chcesz, aby funkcja zmieniła zmienną wywołującego. Dodaj & do typu parametru, a stanie się on referencją, czyli aliasem oryginału, a nie kopią:

#include <iostream>
using namespace std;

void addTen(int& n) {   // n odnosi się do zmiennej wywołującego
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15: oryginał się zmienił
    return 0;
}

Jedyna różnica względem pierwszego przykładu to &, ale teraz n i score to ten sam obiekt. To standardowy sposób, by "zwrócić" więcej niż jedną wartość albo zaktualizować coś w miejscu. Klasyczne zastosowanie to zamiana dwóch zmiennych:

#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;
}

Bez & funkcja swapValues zamieniłaby dwie kopie, a main nie zobaczyłby żadnej zmiany. To bardzo częsty błąd początkujących.

Referencje const: tani dostęp tylko do odczytu

Przekazywanie przez wartość kopiuje argument. Dla int to nic nie kosztuje, ale kopiowanie dużego string albo vector przy każdym wywołaniu to realna, zmarnowana praca. Rozwiązaniem jest referencja const (const T&): dostajesz szybkość referencji (bez kopii) plus pilnowaną przez kompilator obietnicę, że argument nie zostanie zmieniony.

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

// nie powstaje kopia napisu i nie da się go przypadkiem zmienić
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // byłoby błędem kompilacji: name jest const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& może się też związać z wartością tymczasową
    return 0;
}

Przydatna zasada: małe typy wbudowane (int, double, char, bool, wskaźniki) przekazuj przez wartość, a duże obiekty, które tylko odczytujesz, przez referencję const. Zwykłe T& bez const zostaw na sytuacje, gdy naprawdę zamierzasz zmienić obiekt wywołującego.

Subtelna pułapka: zwykłe int& n nie może się związać z wartością tymczasową ani literałem. addTen(5) z pierwszego przykładu nie skompilowałoby się, gdyby parametr był typu int&, bo 5 to nie zmienna, której można nadać alias. const int& może związać się z 5 i to kolejny powód, dla którego referencje const są tak powszechne.

Argumenty domyślne

Parametrowi możesz nadać wartość zastępczą, dzięki czemu wywołujący może go pominąć. Gdy argumentu brakuje, używana jest wartość domyślna:

#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);   // podane wszystkie trzy
    return 0;
}

Dwie reguły często zaskakują. Po pierwsze, wartości domyślne muszą być na końcu: gdy jeden parametr ma wartość domyślną, każdy kolejny też musi ją mieć. Nie napiszesz void f(int a = 1, int b), bo nie byłoby sposobu, by podać b, pomijając a. Po drugie, gdy funkcja jest zadeklarowana w nagłówku, a zdefiniowana gdzie indziej, wartość domyślną podaj tylko w deklaracji i nigdy nie powtarzaj jej w definicji: powtórzenie to błąd kompilacji.

Przekazywanie tablic i wektorów

Surowa tablica przy przekazaniu rozpada się do wskaźnika, więc funkcja traci informację o jej rozmiarze. Prawie zawsze przekazujesz więc obok niej długość:

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // arr to tutaj w rzeczywistości int*
    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;
}

Ponieważ tablica stała się wskaźnikiem, sizeof(arr) wewnątrz sum dałoby rozmiar wskaźnika, a nie tablicy. To osławiony błąd. We współczesnym C++ wybieraj std::vector (albo std::span w C++20) przekazywany przez referencję const, który zna własny rozmiar:

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

int sum(const vector<int>& v) {   // bez kopii, zna własny rozmiar
    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;
}

Zwróć uwagę na const&: usuń je, a każde wywołanie skopiuje cały wektor. Przy czterech elementach to nieszkodliwe, ale przy milionie elementów to cichy pożeracz wydajności.

Parametry wskaźnikowe

Możesz też przekazać wskaźnik (T*). Podobnie jak referencja pozwala on funkcji sięgnąć do danych wywołującego, ale wskaźnik można przestawić albo może być pusty, więc to właściwe narzędzie, gdy "brak wartości" jest dopuszczalną opcją:

#include <iostream>
using namespace std;

// zwraca false, gdy nie ma gdzie zapisać wyniku
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // zabezpieczenie przed nullem
    *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;
}

Wywołujący przekazuje &value, aby udostępnić jej adres, a funkcja zapisuje przez *out. Kluczowa różnica względem referencji: wskaźnik może być nullptr, więc funkcja, która go przyjmuje, powinna to sprawdzić przed wyłuskaniem. Pominięcie tego zabezpieczenia i wyłuskanie pustego wskaźnika to niezdefiniowane zachowanie, zwykle kończące się awarią. Jeśli "brak wartości" nigdy nie ma sensu, referencja jest czystsza, bo w ogóle nie może być pusta.

Dalej: referencje

To przy parametrach referencje najbardziej się przydają, ale są też samodzielną funkcją języka: aliasami, które możesz utworzyć dla dowolnej zmiennej, nie tylko w sygnaturze funkcji. Następna strona pokazuje, jak referencje działają same w sobie: jak je deklarować, dlaczego trzeba je od razu zainicjalizować, czym różni się referencja do l-wartości od referencji const i w jaki subtelny sposób referencja może stać się wisząca.