const i stałe w C++: const, constexpr i consteval

Po co istnieją stałe

Stała to wartość, którą obiecujesz nigdy nie zmieniać po jej ustawieniu. Oznaczenie czegoś jako const załatwia dwie sprawy naraz: dokumentuje twoją intencję dla każdego, kto czyta kod, i pozwala kompilatorowi tej intencji pilnować. Każda linia, która próbuje zmienić wartość, staje się błędem kompilacji, a nie cichym błędem w czasie działania.

Słowo kluczowe auto pozwalało kompilatorowi wywnioskować typ zmiennej, a const ogranicza to, co możesz z tą zmienną zrobić. Oba łączą się swobodnie: const auto limit = 100; to int tylko do odczytu.

Deklarowanie wartości const

Postaw const przed typem. Zmienna const musi zostać zainicjalizowana w tej samej linii, bo później nie ma już momentu, w którym wolno cokolwiek do niej przypisać.

#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; // błąd: przypisanie do zmiennej tylko do odczytu
    return 0;
}

Odkomentuj przypisanie, a program się nie skompiluje: kompilator zgłosi "assignment of read-only variable". O to właśnie chodzi: pomyłka zostaje wyłapana, zanim program w ogóle ruszy.

Częsty nawyk przeniesiony z C to #define MAX_USERS 100. Unikaj go. Makro to ślepa podmiana tekstu bez typu i bez poszanowania zasięgu, więc nie da się go podejrzeć w debugerze, a do tego generuje mylące komunikaty błędów. Zmienna const (lub constexpr) jest sprawdzana pod kątem typu i ma zasięg jak każda inna.

const kontra constexpr

Oba słowa kluczowe dają wartość, która nie może się zmienić, ale odpowiadają na różne pytania. const mówi "to się nie zmieni po ustawieniu". constexpr mówi mocniej "to da się obliczyć w czasie kompilacji", a wszystko, co jest constexpr, jest automatycznie także const.

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: wartość z czasu działania, tylko do odczytu
    constexpr int b = 10;     // OK: znana w czasie kompilacji
    // constexpr int c = n;   // błąd: n nie jest stałą czasu kompilacji

    int grid[b];              // legalne: rozmiar tablicy musi być stałą czasu kompilacji
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

Praktyczna zasada: sięgaj po constexpr zawsze, gdy wartość to stały literał albo obliczenie, które kompilator może wykonać (rozmiary tablic, długości buforów, etykiety switch, argumenty szablonów). Zwykłego const używaj, gdy wartość ustala się w czasie działania, ale potem nie powinna się zmieniać, na przykład kopia const argumentu funkcji.

Od C++20 istnieje też consteval, używane dla funkcji, które muszą wykonać się w czasie kompilacji:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // obliczane podczas kompilacji

Funkcja constexpr może wykonać się w czasie kompilacji; funkcja consteval zawsze musi, inaczej jest to błąd.

Wskaźniki i const: czytaj od prawej do lewej

Tu const najczęściej myli ludzi, bo słowo kluczowe może stać po obu stronach *, a oba znaczenia są przeciwne. Sztuczka polega na czytaniu deklaracji od prawej do lewej.

#include <iostream>
using namespace std;

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

    const int* p1 = &x;   // wskaźnik na const int: można przestawić, nie można zmienić *p1
    p1 = &y;              // OK
    // *p1 = 5;           // błąd: *p1 jest const

    int* const p2 = &x;   // stały wskaźnik na int: można zmienić *p2, nie można przestawić
    *p2 = 99;             // OK
    // p2 = &y;           // błąd: p2 jest const

    const int* const p3 = &x; // stały wskaźnik na const int: nie wolno ani jednego, ani drugiego

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

Czytaj int* const p2 od prawej do lewej: "p2 to stały wskaźnik na int". const int* p1 czytaj jako "p1 to wskaźnik na const int". Pomyl to, a stracisz sporo czasu na błąd, który mówi, że nie możesz zmienić czegoś, co wydawało się modyfikowalne.

Praktyczna pułapka: nigdy nie bierz adresu obiektu const i nie usuwaj const rzutowaniem, aby zmienić obiekt pod spodem. Jeśli oryginalny obiekt naprawdę był const, to niezdefiniowane zachowanie, a kompilator może założyć, że wartość nigdy się nie zmienia, więc twój "zapis" może zostać po prostu zignorowany.

Referencje const jako parametry funkcji

Najczęstsze codzienne zastosowanie const to przekazywanie dużych obiektów przez referencję bez kopiowania. Parametr const& unika kopii i obiecuje, że funkcja nie zmieni argumentu wywołującego.

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

// Nie powstaje kopia napisu i nie da się go przypadkiem zmienić.
void greet(const string& name) {
    // name += "!"; // błąd: name jest const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& wiąże się też z tymczasowym literałem
    return 0;
}

Przekazywanie przez const& to domyślny wybór dla każdego parametru większego niż kilka bajtów (napisy, wektory, własne klasy). Pozwala też funkcji przyjąć wartość tymczasową, taką jak "Grace": zwykła referencja bez const nie może się związać z wartością tymczasową, więc usunięcie tu const odrzuciłoby drugie wywołanie.

Metody const

Pisząc klasę, oznaczaj każdą metodę, która nie zmienia obiektu, końcowym const. Dzięki temu metodę można wywołać na instancjach const i przez parametry const&; bez tego nie odczytasz własnego obiektu przez uchwyt const.

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

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // zmienia obiekt -> nie const
    double getBalance() const { return balance; }       // tylko odczyt -> const
};

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

    const Account& ref = a;        // widok tylko do odczytu
    cout << ref.getBalance() << "\n"; // działa tylko dlatego, że getBalance() jest const
    // ref.deposit(10);            // błąd: deposit() nie jest const
    return 0;
}

Dyscyplina oznaczania metod tylko do odczytu jako const nazywa się poprawnością const (const correctness). Zadbaj o nią wcześnie: dodanie const do jednej metody jest łatwe, ale dorabianie const w dużym projekcie później boli, bo zależy od tego każde wywołanie przez referencję const.

Dalej: operatory

Twoje wartości da się już zablokować przez const, więc następny krok to robienie z nimi czegoś. Strona o operatorach omawia operatory arytmetyczne, porównania, logiczne i przypisania, w tym pułapki dzielenia całkowitego, pierwszeństwo operatorów i to, jak const współgra z operatorami przypisania, których nie wolno ci użyć.