Parametri delle funzioni in C++: per valore, riferimento e const

Parametri e argomenti

I parametri di una funzione sono le variabili con un nome nella sua definizione; gli argomenti sono i valori concreti che le passi quando la chiami. La pagina precedente mostrava come definire e chiamare le funzioni; questa pagina riguarda il modo in cui quei valori entrano davvero, perché il C++ ti offre diverse possibilità e la scelta influisce sia sulla correttezza sia sulla velocità.

Il comportamento predefinito in C++ è il passaggio per valore: la funzione riceve una copia.

#include <iostream>
using namespace std;

void addTen(int n) {   // n è una copia di ciò che passi
    n = n + 10;
    cout << "inside: " << n << endl;
}

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

Dentro addTen, n è una variabile separata inizializzata a partire da score. Riassegnare n tocca solo quella copia, quindi in main score resta intatto. È sicuro e prevedibile, perché la funzione non può rovinarti i dati per sbaglio, ed è proprio per questo che è il comportamento predefinito.

Passaggio per riferimento: lasciare che una funzione modifichi il chiamante

A volte vuoi che la funzione modifichi la variabile del chiamante. Aggiungi un & al tipo del parametro e diventa un riferimento, cioè un alias dell'originale, non una copia:

#include <iostream>
using namespace std;

void addTen(int& n) {   // n si riferisce alla variabile del chiamante
    n = n + 10;
}

int main() {
    int score = 5;
    addTen(score);
    cout << score << endl;   // 15, l'originale è cambiato
    return 0;
}

L'unica differenza rispetto al primo esempio è il &, ma ora n e score sono lo stesso oggetto. È il modo standard per "restituire" più di un valore o per aggiornare qualcosa sul posto. Un uso classico è scambiare due variabili:

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

Senza il &, swapValues scambierebbe due copie e main non vedrebbe alcun cambiamento: un bug molto comune tra i principianti.

Riferimenti const: accesso economico in sola lettura

Il passaggio per valore copia l'argomento. Per un int non costa nulla, ma copiare una string o un vector grandi a ogni chiamata è lavoro reale e sprecato. La soluzione è un riferimento const (const T&): ottieni la velocità di un riferimento (nessuna copia) più la promessa, fatta rispettare dal compilatore, di non modificare l'argomento.

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

// nessuna copia della stringa, e non possiamo cambiarla per sbaglio
void greet(const string& name) {
    cout << "Hello, " << name << "!" << endl;
    // name = "x";   // sarebbe un errore di compilazione, name è const
}

int main() {
    string visitor = "Ada";
    greet(visitor);
    greet("temporary");   // const& può legarsi anche a un temporaneo
    return 0;
}

Una regola pratica utile: passa i tipi predefiniti piccoli (int, double, char, bool, puntatori) per valore, e gli oggetti grandi che devi solo leggere per riferimento const. Riserva un semplice T& non const ai casi in cui vuoi davvero modificare l'oggetto del chiamante.

Un'insidia sottile: un semplice int& n non può legarsi a un temporaneo o a un letterale. addTen(5) del primo esempio non compilerebbe se il parametro fosse int&, perché 5 non è una variabile di cui puoi creare un alias. Un const int& può legarsi a 5, un motivo in più per cui i riferimenti const sono così diffusi.

Argomenti predefiniti

Puoi dare a un parametro un valore di riserva, così i chiamanti possono ometterlo. Se l'argomento manca, viene usato il valore predefinito:

#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);   // tutti e tre forniti
    return 0;
}

Due regole mettono in difficoltà. Primo, i valori predefiniti devono stare in fondo: quando un parametro ha un valore predefinito, devono averlo anche tutti quelli che lo seguono. Non puoi scrivere void f(int a = 1, int b), perché non ci sarebbe modo di fornire b saltando a. Secondo, quando una funzione è dichiarata in un header e definita altrove, metti il valore predefinito solo nella dichiarazione e non ripeterlo mai nella definizione: ripeterlo è un errore di compilazione.

Passare array e vector

Un array classico decade a puntatore quando viene passato, quindi la funzione perde traccia della sua dimensione: quasi sempre passi anche la lunghezza.

#include <iostream>
using namespace std;

int sum(const int arr[], int size) {   // qui arr in realtà è un 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;
}

Dato che l'array è diventato un puntatore, sizeof(arr) dentro sum restituirebbe la dimensione di un puntatore, non dell'array: un bug famigerato. Nel C++ moderno preferisci uno std::vector (o std::span in C++20), passato per riferimento const, che porta con sé la propria dimensione:

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

int sum(const vector<int>& v) {   // nessuna copia, conosce la propria dimensione
    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;
}

Nota il const&: se lo togli, ogni chiamata copia l'intero vector. Per un vector di quattro elementi è innocuo, ma con un milione di elementi è un pozzo silenzioso di prestazioni.

Parametri puntatore

Puoi anche passare un puntatore (T*). Come un riferimento, permette alla funzione di raggiungere i dati del chiamante, ma un puntatore può essere spostato su un altro oggetto o essere nullo, quindi è lo strumento giusto quando "nessun valore" è un'opzione legittima:

#include <iostream>
using namespace std;

// restituisce false quando non c'è dove scrivere il risultato
bool tryParseDouble(const char* text, double* out) {
    if (out == nullptr) return false;   // protezione contro il puntatore nullo
    *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;
}

Il chiamante passa &value per condividere il proprio indirizzo, e la funzione scrive attraverso *out. La differenza chiave rispetto ai riferimenti: un puntatore potrebbe essere nullptr, quindi una funzione che lo riceve dovrebbe controllarlo prima di dereferenziarlo. Saltare quel controllo e dereferenziare un puntatore nullo è comportamento indefinito, di solito un crash. Se "nessun valore" non ha mai senso, un riferimento è più pulito, perché fin dall'inizio non può essere nullo.

Prossimo: Riferimenti

I parametri sono il posto in cui i riferimenti danno il meglio, ma i riferimenti sono una funzionalità a sé stante: alias che puoi creare per qualsiasi variabile, non solo nella firma di una funzione. La prossima pagina approfondisce come funzionano i riferimenti da soli: come dichiararli, perché vanno inizializzati subito, la differenza tra un riferimento lvalue e un riferimento const, e i modi subdoli in cui un riferimento può finire per essere pendente.