const e costanti in C++: const, constexpr e consteval

Perché esistono le costanti

Una costante è un valore che prometti di non cambiare mai dopo averlo impostato. Marcare qualcosa come const fa due cose insieme: documenta la tua intenzione per chiunque legga il codice e permette al compilatore di farla rispettare, perché qualsiasi riga che provi a modificare il valore diventa un errore di compilazione invece di un bug silenzioso a runtime.

Mentre la parola chiave auto lasciava al compilatore il compito di dedurre il tipo di una variabile, const limita ciò che puoi fare con quella variabile. Le due si combinano liberamente: const auto limit = 100; è un int di sola lettura.

Dichiarare un valore const

Metti const prima del tipo. Una variabile const deve essere inizializzata sulla stessa riga, perché non esiste un momento successivo in cui ti sia permesso assegnarle un valore.

#include <iostream>
using namespace std;

int main() {
    const int maxUsers = 100;
    const double pi = 3.14159;

    cout << "Max users: " << maxUsers << "\n";
    cout << "Pi: " << pi << "\n";

    // maxUsers = 200; // errore: assegnazione a una variabile di sola lettura
    return 0;
}

Togli il commento all'assegnazione e il programma non compila: il compilatore segnala "assignment of read-only variable". È proprio questo il punto: l'errore viene individuato prima ancora che il programma venga eseguito.

Un'abitudine comune da principianti ereditata dal C è #define MAX_USERS 100. Evitala. Una macro è una sostituzione di testo alla cieca, senza tipo e senza rispetto per lo scope, quindi non si può ispezionare in un debugger e produce messaggi di errore confusi. Una variabile const (o constexpr) viene controllata nel tipo e ha uno scope come qualsiasi altra.

const e constexpr

Entrambe le parole chiave ti danno un valore che non può cambiare, ma rispondono a domande diverse. const dice "questo non cambia mai dopo essere stato impostato". constexpr dice qualcosa di più forte, "questo si può calcolare in fase di compilazione", e tutto ciò che è constexpr è automaticamente anche const.

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: valore a runtime, di sola lettura
    constexpr int b = 10;     // OK: noto in fase di compilazione
    // constexpr int c = n;   // errore: n non è una costante nota in compilazione

    int grid[b];              // valido: la dimensione dell'array deve essere una costante nota in compilazione
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

La regola pratica: usa constexpr ogni volta che il valore è un letterale fisso o un calcolo che il compilatore può fare (dimensioni di array, lunghezze di buffer, etichette switch, argomenti template). Usa un semplice const quando il valore viene deciso a runtime ma non deve cambiare dopo, come una copia const di un argomento di funzione.

Da C++20 esiste anche consteval, che si usa sulle funzioni che devono essere eseguite in fase di compilazione:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // calcolato durante la compilazione

Una funzione constexpr può essere eseguita in fase di compilazione; una funzione consteval deve esserlo sempre, altrimenti è un errore.

Puntatori e const: leggi da destra a sinistra

È qui che const manda in confusione, perché la parola chiave può stare su entrambi i lati dell'* e i due significati sono opposti. Il trucco è leggere la dichiarazione da destra a sinistra.

#include <iostream>
using namespace std;

int main() {
    int x = 1, y = 2;

    const int* p1 = &x;   // puntatore a const int: si può ripuntare, non si può modificare *p1
    p1 = &y;              // OK
    // *p1 = 5;           // errore: *p1 è const

    int* const p2 = &x;   // puntatore const a int: si può modificare *p2, non si può ripuntare
    *p2 = 99;             // OK
    // p2 = &y;           // errore: p2 è const

    const int* const p3 = &x; // puntatore const a const int: nessuna delle due cose è permessa

    cout << *p1 << " " << *p2 << " " << *p3 << "\n";
    return 0;
}

Leggi int* const p2 da destra a sinistra: "p2 è un puntatore const a int". Leggi const int* p1 come "p1 è un puntatore a const int". Se sbagli, perderai parecchio tempo confuso da un errore che dice che non puoi modificare qualcosa che pensavi fosse modificabile.

Un'insidia pratica: non prendere mai l'indirizzo di un const per poi eliminare il const con un cast e modificare l'oggetto sottostante. Farlo è comportamento indefinito se l'oggetto originale era davvero const, e il compilatore è libero di presumere che il valore non cambi mai: la tua "scrittura" potrebbe semplicemente essere ignorata.

Riferimenti const come parametri di funzione

L'uso quotidiano più comune di const è passare oggetti grandi per riferimento senza copiarli. Un parametro const& evita la copia e promette che la funzione non modificherà l'argomento del chiamante.

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

// Nessuna copia della stringa, e non possiamo modificarla per sbaglio.
void greet(const string& name) {
    // name += "!"; // errore: name è const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& si lega anche a un letterale temporaneo
    return 0;
}

Il passaggio per const& è la scelta predefinita per qualsiasi parametro più grande di un paio di byte (stringhe, vector, le tue classi). Nota che permette alla funzione di accettare anche un temporaneo come "Grace": un semplice riferimento non const non può legarsi a un temporaneo, quindi togliere il const qui farebbe rifiutare la seconda chiamata.

Funzioni membro const

Quando scrivi una classe, marca con un const finale ogni metodo che non modifica l'oggetto. È questo che rende il metodo chiamabile su istanze const e su parametri const&: senza, non puoi leggere il tuo stesso oggetto attraverso un riferimento const.

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

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // modifica -> non const
    double getBalance() const { return balance; }       // sola lettura -> const
};

int main() {
    Account a;
    a.deposit(50);

    const Account& ref = a;        // una vista di sola lettura
    cout << ref.getBalance() << "\n"; // funziona solo perché getBalance() è const
    // ref.deposit(10);            // errore: deposit() non è const
    return 0;
}

La disciplina di marcare come const i metodi di sola lettura si chiama const correctness. Impostala bene fin da subito: aggiungere const a un metodo che avrebbe dovuto esserlo è facile, ma introdurre const più tardi in un codebase grande è doloroso, perché ogni chiamante che passa da un riferimento const ne dipende.

Prossimo: Operatori

Ora che puoi bloccare i tuoi valori con const, il passo successivo è farci qualcosa. La pagina sugli operatori tratta gli operatori aritmetici, di confronto, logici e di assegnazione, comprese le insidie della divisione intera, la precedenza degli operatori e il modo in cui const interagisce con gli operatori di assegnazione che non ti è permesso usare.