const и контракт на неизменяемость

1. Зачем нужен const

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

Идея простая: если переменная по смыслу не должна меняться, давайте так и скажем языку. Тогда компилятор станет вашим союзником: он будет ловить случайные изменения, а код станет понятнее даже вам самому через неделю (или преподавателю через 30 секунд).

Что означает const

Начнём с формулировки без магии. Ключевое слово const означает: значение нельзя менять после инициализации. Не «вроде бы нельзя», не «не рекомендуется», а именно «компилятор запретит».

Важно уловить тонкость: const говорит не «значение известно заранее», а «значение неизменяемо после того, как мы его получили». Поэтому const отлично дружит со значениями, введёнными пользователем: вы можете считать число из std::cin, а потом «заморозить» его в const-переменной, чтобы случайно не испортить в дальнейших вычислениях.

Небольшой пример — самая честная демонстрация:

#include <iostream>

int main() {
    const int max_retries = 3;

    std::cout << max_retries << '\n'; // 3
    max_retries = 4;              // ошибка компиляции

    return 0;
}

Здесь max_retries — это «настройка», и если она «настройка», то логично, что она не должна внезапно меняться посреди программы.

const требует инициализации

Сейчас будет момент, где многие впервые слышат от компилятора твёрдое «нет». Обычную переменную можно объявить, а потом присвоить ей значение позже (хотя это тоже нужно делать аккуратно). Но const-переменная обязана получить значение сразу, иначе… а что именно мы собираемся «замораживать»?

Поэтому такая запись невалидна:

#include <iostream>

int main() {
    const int x;   // ошибка: const без инициализации

    return 0;
}

А такая — валидна:

#include <iostream>

int main() {
    const int x{10};
    std::cout << x << '\n'; // 10

    return 0;
}

Психологически это полезно: если вы видите const, вы сразу понимаете, что у переменной есть нормальное начальное значение. И у компилятора тоже нет поводов гадать, что там внутри.

3. const и инициализация: =, (), {}

После предыдущей лекции возникает естественный вопрос: «а const работает только с каким‑то одним видом инициализации?». Нет, const — это не отдельная «форма инициализации». Это модификатор, который говорит: «после того как инициализировали — не трогать».

Давайте на одном примере покажем три стиля:

#include <iostream>

int main() {
    const int a = 10;
    const int b(10);
    const int c{10};

    std::cout << a << ' ' << b << ' ' << c << '\n'; // 10 10 10
    return 0;
}

Почему часто рекомендуют {}? По той же причине, что и без const: фигурные скобки обычно лучше ловят «опасные» места, где вы могли потерять данные при преобразовании типов. А ещё {} визуально напоминают: «мы создаём значение», а не «делаем действие».

4. const и значение на этапе компиляции

Можно ли придумать ещё более «константное» значение, чем const? Да, в C++ есть отдельная, более строгая идея — константные выражения (constant expressions): то, что компилятор действительно обязан уметь вычислить заранее. Это значение или выражение, которое не просто неизменяемо, а уже известно ещё до запуска программы — на этапе компиляции.

Сегодня мы не уходим в constexpr (это будет в следующей лекции), но различие зафиксируем:

• const отвечает на вопрос: «можно ли менять значение после получения?»
• constexpr отвечает на вопрос: «должно ли быть известно значение при компиляции?»

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

#include <iostream>

int main() {
    int x{};
    std::cin >> x;

    const int snapshot{x};      // “снимок” значения
    std::cout << snapshot << '\n';

    return 0;
}

5. Практика: где const особенно полезен

Сценарий «снимок» значения

Сейчас будет очень практичная мысль. Иногда переменная по природе изменчива (например, вы считаете сумму, и она растёт), но вам нужно «зафиксировать» какое‑то состояние и дальше использовать его как факт. Это как сделать фото счётчика электроэнергии: счётчик крутится, но фото уже не изменится, и по нему вы потом считаете платёж.

Сценарий: пользователь ввёл базовую цену, а вы дальше много раз используете её для расчётов. Если вы оставите это значение в обычной переменной, вы можете случайно её перезаписать (особенно если код растёт). Поэтому делаем «снимок».

#include <iostream>

int main() {
    double entered_price{};
    std::cin >> entered_price;

    const double base_price{entered_price};  // фиксируем
    std::cout << base_price << '\n';

    return 0;
}

Это не «обязательный стиль», это инструмент. Но когда начинаете писать программы длиннее 30 строк, вы внезапно понимаете, что «случайно перезаписал» — это не гипотеза, это образ жизни.

const против «магических чисел»

Одна из самых частых проблем в коде новичков — числа, которые появляются «просто потому что». Сегодня 0.2 — это НДС, завтра это скидка, послезавтра это коэффициент, который вы уже не помните. Такие числа называют «магическими».

const позволяет дать числу имя, и это резко повышает читабельность. Причём не надо сразу уходить в сложные архитектурные идеи: достаточно просто вынести коэффициенты в переменные.

Сравните:

#include <iostream>

int main() {
    double price{100.0};
    double total = price + price * 0.2; // что такое 0.2?
    std::cout << total << '\n';         // 120
    return 0;
}

и:

#include <iostream>

int main() {
    const double vat_rate{0.2};
    double price{100.0};

    double total = price + price * vat_rate;
    std::cout << total << '\n'; // 120

    return 0;
}

Во втором варианте даже без комментариев видно, что происходит. И если вы захотите поменять ставку — вы меняете её в одном месте.

Мини-схема: отделяем факты от рабочих переменных

Когда вы пишете программу, у вас есть переменные двух типов (по смыслу): «данные, которые должны меняться» и «данные, которые должны оставаться фактами». const помогает разделить их прямо в коде. Это упрощает отладку: вы знаете, какие значения вы точно не могли испортить случайным присваиванием.

Нарисуем простую блок-схему логики вычисления цены, которую мы сейчас будем собирать в единый пример:

flowchart TD
    A[Ввод исходных данных] --> B[Фиксируем факты const]
    B --> C[Считаем промежуточные значения]
    C --> D[Считаем итог]
    D --> E[Вывод результата]

В реальном коде «фактами» часто становятся коэффициенты, лимиты, исходные параметры расчёта, а «меняющимися» — накопители, суммы, счётчики, текущие значения.

6. Практический пример: мини-касса

Теперь соберём маленькую консольную программу, которую можно мысленно считать нашим «учебным приложением» на текущих темах. Мы не используем функции, контейнеры и всё такое (это будет позже), зато честно применяем переменные, инициализацию и const.

Сюжет: пользователь вводит цену товара и процент скидки. Ставка НДС у нас фиксирована. Мы считаем итоговую цену.

Версия 1: наивно (и хрупко)

Начнём с простого варианта, который технически работает, но легко ломается случайными правками:

#include <iostream>

int main() {
    double price{};
    double discount_percent{};

    std::cin >> price >> discount_percent;

    discount_percent = discount_percent / 100.0; // переиспользуем переменную
    double total = price - price * discount_percent;

    std::cout << total << '\n';
    return 0;
}

Проблема не в том, что это «плохо». Проблема в том, что переменная discount_percent поменяла смысл: сначала это «проценты», потом это «доля». Через пару дней вы забудете, на каком этапе вы сейчас.

Версия 2: отделяем факты и фиксируем

Сделаем аккуратнее: введённые значения фиксируем в const, а промежуточные считаем отдельно.

#include <iostream>

int main() {
    double price_input{};
    double discount_input{};

    std::cin >> price_input >> discount_input;

    const double price{price_input};
    const double discount_percent{discount_input};

    const double discount_rate{discount_percent / 100.0};
    double total{price - price * discount_rate};

    std::cout << total << '\n';
    return 0;
}

Здесь заметно, что discount_percent не меняется, discount_rate — отдельная сущность, и вы не превращаете одну переменную в «хамелеона».

Версия 3: добавляем НДС как const

Теперь усложним пример буквально на одну мысль: ставка НДС фиксирована и не должна меняться.

#include <iostream>

int main() {
    const double vat_rate{0.2};

    double price_input{};
    double discount_input{};
    std::cin >> price_input >> discount_input;

    const double price{price_input};
    const double discount_rate{discount_input / 100.0};

    const double discounted{price - price * discount_rate};
    const double total{discounted + discounted * vat_rate};

    std::cout << total << '\n';
    return 0;
}

Обратите внимание на эффект: почти все переменные стали const, потому что мы их не обязаны менять. Меняемыми остаются только «входные буферы» (price_input, discount_input) — и то, строго говоря, мы могли бы и их не делать меняемыми, просто так нагляднее. В результате программа становится похожа на последовательность формул, и это очень приятный стиль для расчётных задач.

7. const и поддержка кода в будущем

Есть простой критерий: если переменная меняется, читатель должен искать по коду, где именно и почему. Если переменная const, читатель расслабляется: «окей, это факт, его можно использовать, но не надо отслеживать, где он мог измениться».

Это особенно полезно, когда вы исправляете баги. Часто баг выглядит так: «почему сумма стала отрицательной?». И выясняется, что где-то случайно перезаписали коэффициент или «исходную сумму». const превращает такие баги в ошибки компиляции — то есть вы ловите проблему раньше, чем программа вообще запустится.

Приятный бонус: const дисциплинирует. Он заставляет вас думать: «это параметр?» «это настройка?» «это факт?» или «это рабочая переменная?». И постепенно код становится менее случайным.

8. Типичные ошибки при работе с const

Ошибка №1: объявить const без инициализации.
Так не работает, потому что const должен «заморозить» конкретное значение. Если написать const int x;, то непонятно, что именно мы запрещаем менять. Правильный путь — инициализировать сразу: const int x{10}; или const int x = 10;.

Ошибка №2: ставить const на переменную, которая по смыслу должна меняться.
Иногда новички пытаются «сделать всё безопасным» и пишут const даже на сумму, которую накапливают, или на счётчик. Компилятор начнёт ругаться, а вы — злиться на мир. Здесь важно различать: const для фактов (лимит, ставка, исходные данные, снимок значения), а изменяемые переменные оставляем обычными.

Ошибка №3: путать const и «значение известно компилятору».
const — про запрет изменения после инициализации. Значение может прийти от пользователя, из ввода, из времени выполнения — и всё равно быть const. А требование «значение вычисляется при компиляции» относится к другой сущности, которая будет в следующей лекции (constexpr).

Ошибка №4: менять смысл переменной «по дороге», вместо создания новой.
Классический пример: переменная была «проценты», стала «доля», потом стала «итоговая скидка в евро». Это делает код хрупким. const часто помогает поймать этот стиль мышления и заставляет заводить новые понятные имена: discount_percent, discount_rate, discount_value.

Ошибка №5: бояться const, потому что «вдруг пригодится поменять».
Это очень человеческая привычка: оставить себе «запасной выход». Но в коде такой запасной выход превращается в дыру: завтра вы (или кто-то другой) действительно случайно поменяете то, что менять нельзя. Если по смыслу значение не должно меняться — фиксируйте это. Если позже выяснится, что всё-таки должно — вы снимете const осознанно, в конкретном месте, с пониманием причины.