const и константы в C++: const, constexpr и consteval

Зачем нужны константы

Константа — это значение, которое вы обещаете никогда не менять после того, как задали его. Пометка чего-либо как const делает сразу две вещи: документирует ваше намерение для всех, кто читает код, и позволяет компилятору обеспечить это намерение — любая строка, пытающаяся изменить значение, становится ошибкой компиляции, а не тихим багом во время выполнения.

Если ключевое слово auto позволяет компилятору вывести тип переменной, то const ограничивает то, что вы можете делать с этой переменной. Они свободно сочетаются: const auto limit = 100; — это int только для чтения.

Объявление const-значения

Поставьте const перед типом. Переменную const обязательно инициализировать в той же строке, потому что нет более позднего момента, когда вам было бы разрешено присвоить ей значение.

#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; // ошибка: присваивание переменной только для чтения
    return 0;
}

Раскомментируйте присваивание — и программа не скомпилируется: компилятор сообщит «assignment of read-only variable». В этом и весь смысл: ошибка ловится ещё до того, как программа запустится.

Распространённая привычка новичков, перенесённая из C, — это #define MAX_USERS 100. Избегайте её. Макрос — это слепая текстовая подстановка без типа и без учёта области видимости, поэтому его нельзя осмотреть в отладчике, и он порождает запутанные сообщения об ошибках. Переменная const (или constexpr) проходит проверку типов и имеет область видимости, как и всё остальное.

const vs constexpr

Оба ключевых слова дают вам значение, которое нельзя изменить, но они отвечают на разные вопросы. const говорит: «это никогда не меняется после установки». constexpr говорит более сильное: «это можно вычислить во время компиляции» — и всё, что constexpr, автоматически является и const.

#include <iostream>
using namespace std;

int main() {
    int n = 5;
    const int a = n;          // OK: значение времени выполнения, просто только для чтения
    constexpr int b = 10;     // OK: известно во время компиляции
    // constexpr int c = n;   // ошибка: n не является константой времени компиляции

    int grid[b];              // допустимо: размер массива должен быть константой времени компиляции
    cout << "Array length: " << sizeof(grid) / sizeof(grid[0]) << "\n";
    cout << a << " " << b << "\n";
    return 0;
}

Практическое правило: используйте constexpr, когда значение — это фиксированный литерал или вычисление, которое может выполнить компилятор (размеры массивов, длины буферов, метки switch, аргументы шаблонов). Используйте простой const, когда значение определяется во время выполнения, но не должно меняться после этого — например, const-копия аргумента функции.

Начиная с C++20 есть также consteval, применяемый к функциям, которые обязаны выполняться во время компиляции:

consteval int square(int x) { return x * x; }
constexpr int area = square(8); // вычислено во время компиляции

Функция constexpr может выполняться во время компиляции; функция consteval всегда обязана это делать, иначе это ошибка.

Указатели и const: читайте справа налево

Именно здесь const сбивает людей с толку, потому что ключевое слово может стоять по любую сторону от *, и эти два значения противоположны. Хитрость в том, чтобы читать объявление справа налево.

#include <iostream>
using namespace std;

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

    const int* p1 = &x;   // указатель на const int: можно перенаправить, нельзя изменить *p1
    p1 = &y;              // OK
    // *p1 = 5;           // ошибка: *p1 является const

    int* const p2 = &x;   // константный указатель на int: можно изменить *p2, нельзя перенаправить
    *p2 = 99;             // OK
    // p2 = &y;           // ошибка: p2 является const

    const int* const p3 = &x; // константный указатель на const int: ни то, ни другое не разрешено

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

Читайте int* const p2 справа налево: «p2 — это константный указатель на int». Читайте const int* p1 как «p1 — это указатель на const int». Ошибётесь здесь — и потеряете реальное время в недоумении из-за ошибки, которая говорит, что вы не можете изменить то, что считали изменяемым.

Практическая ловушка: никогда не берите адрес const и не отбрасывайте const с помощью приведения, чтобы изменить нижележащий объект. Это неопределённое поведение, если исходный объект действительно был const, и компилятор вправе считать, что значение никогда не меняется — ваша «запись» может быть просто проигнорирована.

const-ссылки как параметры функций

Самое частое повседневное применение const — передача больших объектов по ссылке без копирования. Параметр const& избегает копии и обещает, что функция не изменит аргумент вызывающей стороны.

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

// Копия строки не создаётся, и мы не можем случайно её изменить.
void greet(const string& name) {
    // name += "!"; // ошибка: name является const
    cout << "Hello, " << name << "!\n";
}

int main() {
    string user = "Ada";
    greet(user);
    greet("Grace"); // const& также связывается с временным литералом
    return 0;
}

Передача по const& — выбор по умолчанию для любого параметра больше пары байтов (строки, векторы, ваши собственные классы). Обратите внимание, что это также позволяет функции принимать временный объект вроде "Grace" — обычная неконстантная ссылка не может связаться с временным объектом, поэтому, убрав здесь const, вы отклонили бы этот второй вызов.

const-методы

Когда вы пишете класс, помечайте любой метод, который не изменяет объект, завершающим const. Именно это делает метод вызываемым на const-экземплярах и const&-параметрах — без этого вы не сможете прочитать собственный объект через const-дескриптор.

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

class Account {
    double balance = 0;
public:
    void deposit(double amount) { balance += amount; } // изменяет -> не const
    double getBalance() const { return balance; }       // только чтение -> const
};

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

    const Account& ref = a;        // представление только для чтения
    cout << ref.getBalance() << "\n"; // работает только потому, что getBalance() является const
    // ref.deposit(10);            // ошибка: deposit() не является const
    return 0;
}

Дисциплину пометки методов только для чтения как const называют const correctness. Делайте это правильно с самого начала — метод, который должен был быть const, легко добавить, но дооснащать const в большой кодовой базе позже мучительно, потому что от этого зависит каждый вызывающий через const-ссылку.

Далее: операторы

Теперь, когда ваши значения можно зафиксировать с помощью const, следующий шаг — что-то с ними делать. Страница про операторы охватывает арифметические, сравнения, логические операторы и операторы присваивания — включая подводные камни целочисленного деления, приоритет операторов и то, как const взаимодействует с операторами присваивания, которые вам не разрешено использовать.