Переменные

auto выводит тип из инициализатора по правилам вывода аргументов шаблона; верхнеуровневые const/& отбрасываются — const auto& их сохраняет. C++14 добавил auto-возврат. decltype(auto) сохраняет точный тип. C++20 auto-параметры — сокращённые шаблоны.

enum (нескопированный) выводит перечислители в окружающий scope и неявно конвертируется в int. enum class (скопированный, C++11) держит их в своём scope и не конвертируется неявно — нужен static_cast. Оба позволяют задать базовый тип.

extern имеет два применения: (1) объявление переменной или функции из другой TU — адрес разрешает компоновщик; (2) extern "C" отключает name mangling для C-интеропа. Без extern объявление переменной в namespace-scope — также определение, нарушая ODR между TU.

Фундаментальные типы: void, bool, символьные (char, wchar_t, char8/16/32_t), целочисленные (short/int/long/long long, знак/беззнак), вещественные (float, double, long double). Размеры определяются реализацией; <cstdint> даёт фиксированные псевдонимы.

lvalue — именованное адресуемое выражение, переживающее выражение. rvalue — временный без стабильного адреса. xvalue (истекающий) — именованный объект, приведённый к rvalue-ссылке через std::move. Перегрузка предпочитает T&& вместо const T& для rvalue, давая move.

const int и int const — один тип. С указателями: const T* переназначается, но значение read-only; T* const фиксирован, но значение изменяемо; const T* const запрещает оба. Ссылка — псевдоним без null, неперепривязываемый. Указатели обычно занимают машинное слово.

volatile сообщает, что переменная может меняться вне контроля программы (железо, обработчики сигналов, setjmp); нельзя кэшировать или переупорядочивать чтения/записи. Не примитив синхронизации: межпоточного порядка нет. Для потокобезопасности — std::atomic.

const — значение нельзя изменить через эту ссылку, но не обязано быть известно при компиляции. constexpr — должно быть вычислимо при компиляции и неявно const. constexpr — для compile-time констант; const — для runtime-неизменяемых.

Временный живёт до конца полного выражения. Привязка const T& или T&& продлевает его до времени жизни ссылки. Продление не передаётся через параметры функции, init членов или std::move. Возврат локального через const& — UB.

Большинство float/double используют IEEE 754: бит знака, смещённую экспоненту, мантиссу. Многие десятичные дроби не представимы точно в двоичном виде, поэтому арифметика накапливает ошибку округления; == ненадёжно.

C++17 разрешает init-statement в if/switch: if (auto it = map.find(key); it != map.end()) { ... }. Переменная видна во всём блоке if/else. Не засоряет окружающий scope, удобно с RAII-guard.

int8_t — тип с точной шириной в 8 бит со знаком, гарантированный стандартом. char может быть знаковым или беззнаковым в зависимости от платформы и флагов компилятора.

Namespace группирует связанные имена против конфликтов. Анонимное даёт содержимому внутреннюю компоновку — как static на уровне файла, но и для типов/классов. К вложенным — через :: или using. C++17 разрешает namespace A::B::C { ... }.

Используйте std::numeric_limits<T> из <limits>: ::max(), ::lowest(). Для целых min() — наиболее отрицательное; для вещественных — наименьшее положительное нормализованное, для наиболее отрицательного — lowest(). C-макросы вроде INT_MAX работают, но не обобщены.

Range-for — сахар над begin()/end(): продвигает итератор до end(). Работает для типов с begin/end (методы или свободные через ADL). Без std::views::enumerate (C++23) индекса нет; изменение контейнера инвалидирует итератор (UB).

На локальной static даёт статическое время хранения: инициализируется один раз при первом проходе и живёт до завершения программы. На глобале или функции меняет внешнюю компоновку на внутреннюю — невидим вне TU. Два разных применения.

sizeof(T) возвращает размер с padding. Компилятор выравнивает каждое поле по его выравниванию и добавляет trailing padding, чтобы элементы массива оставались выровнены; итог кратен наибольшему выравниванию struct. offsetof и #pragma pack — для инспекции и контроля layout.

Aggregate — класс без пользовательских конструкторов, без private/protected полей и без virtual-функций или virtual-баз; T x{a,b,c}; инициализирует члены в порядке объявления, неперечисленные получают value-инициализацию.

auto следует правилам вывода шаблонов: ссылки и верхнеуровневый const убираются; массивы и функции распадаются в указатели. Поэтому auto x = v[0]; копирует даже если выглядит легковесно. decltype(auto) сохраняет точный объявленный тип, включая ссылки.

Const-корректность — пометка каждой переменной, параметра и метода, не меняющих состояние, как const. Ловит случайные мутации, даёт бесплатные const&-параметры; на const-объекте можно вызвать только const-квалифицированные методы.

decltype(name) — точно объявленный тип (со ссылками/cv). decltype((name)) добавляет &, ведь name в скобках — lvalue. auto снимает ссылки и top-level cv, если не добавить &/const. decltype(auto) (C++14) выводит по правилам decltype.

Каждый отдельный объект должен иметь уникальный адрес; sizeof == 0 позволил бы двум объектам делить адрес. Поэтому стандарт требует sizeof(T) >= 1. Исключение — Empty Base Optimisation: пустой класс как базовый может занимать ноль внутри производного объекта.

Каждый член на смещении, кратном alignof(T); padding заполняет дыры, struct выровнена по наибольшему. Largest-first уменьшает. [[no_unique_address]] (C++20) даёт пустым членам общее хранилище; #pragma pack переопределяет выравнивание.

static имеет четыре применения: (1) статическое хранение локальных (ленивая init); (2) внутренняя компоновка глобалов/функций; (3) члены уровня класса; (4) static-local в методах. SIOF: порядок init нелокальных статиков между TU не определён — A может использовать неинициализированный B.

auto [a, b, c] = expr; распаковывает tuple-подобное (aggregate, std::pair, std::tuple или класс с get<I> + tuple_size) в именованные переменные. auto& — ссылки, const auto& — const-view. Тип каждой выводится из источника.

thread_local T x; даёт каждому потоку свой x, инициализируемый при первом обращении и уничтожаемый при выходе. Применения: per-thread кеши, RNG, error state. Цена: indirection на доступ (TLS slot); shared-библиотека — __tls_get_addr.

UB — стандарт не ограничивает поведение программы; компилятор считает, что UB не возникает, и оптимизирует. Примеры: знаковое переполнение, разыменование null/висячего, выход за границы, неинициализированные чтения, гонки. Не runtime-ошибка: debug может пройти, release — упасть.

Uniform init (C++11) использует {} повсюду и запрещает сужение (int x{3.14} — ошибка). Агрегатная init применима, если у класса нет user-ctor, нет приватных/защищённых нестатических членов, нет виртуальных функций и непубличных баз — T obj{a, b, c} заполняет члены в порядке без ctor.

Default-init T x; оставляет встроенные с неопределённым значением (UB читать) и вызывает default-ctor у классов. Value-init T x{}/T() обнуляет встроенные; для класса без user-ctor зануляет члены, затем зовёт сгенерированный ctor. Zero-init — отдельная стадия для namespace-scope объектов.

constexpr означает, что функция может выполниться при константном вычислении — либо в runtime, в зависимости от аргументов. consteval (C++20) делает функцию немедленной: каждый вызов обязан вычисляться на этапе компиляции. constinit (C++20) форсирует инициализацию статической переменной на этапе компиляции, убивая фиаско порядка инициализации, но переменная остаётся изменяемой.

Сужающее преобразование — это неявное преобразование, способное потерять информацию: из плавающей точки в целое, из более широкого типа в более узкий, либо значение, непредставимое в цели. C++ запрещает сужение внутри brace-инициализации: int x{3.5}; некорректен, тогда как int x = 3.5; компилируется.

std::variant<A,B,C> — типобезопасное теговое объединение, хранящее одно значение из фиксированного compile-time набора; доступ через std::get<T> или std::visit. std::any — type-erased контейнер с открытым в runtime набором. variant — для известных альтернатив; any — для динамических типов.

A 66 B. c печатается как символ A. В c + 1 тип char повышается до int, поэтому результат — 66, печатается как число. Приведение обратно char(c + 1) снова делает его char, и поток печатает 'B' (ASCII 66).

2 2.5 1. 5 / 2 — целочисленное деление, усекающее к нулю. 5.0 / 2 повышает int до double, давая 2.5. % — целочисленный остаток. Учтите: -7 % 3 в C++ равно -1 — знак результата следует за делимым.

Неопределённое поведение: i изменяется дважды (i++ и ++i) и читается без точки следования между побочными эффектами, поэтому стандарт не задаёт результат — разные компиляторы печатают разное, а программа невалидна.

Битовое поле — член с двоеточием и количеством бит: unsigned int flags : 3;. Компилятор упаковывает их в блоки. Порядок внутри блока определяется реализацией; безымянное поле нулевой ширины открывает новый блок; адрес битового поля взять нельзя.

До C++14 включительно порядок вычисления операндов << был неуточнённым, поэтому могло печататься 2 1 0 или 0 1 2. C++17 сделал операнды << вычисляемыми слева направо, поэтому теперь надёжно печатается 0 1 2. Порядок аргументов функций всё ещё неуточнён — избегайте таких побочных эффектов.

Когда объявление можно прочитать как функцию или инициализацию, C++ выбирает функцию. T x(MyArg()); похоже на конструирование, но парсится как функция x, принимающая указатель на функцию, возвращающую MyArg. Лечение — T x{MyArg{}}; или именованный аргумент.

Арифметика int переполняется на больших квадратах, а знаковое переполнение — это неопределённое поведение (а не перенос), поэтому и a[i] * a[i], и накапливаемый int sum могут молча переполниться. Решение: более широкий тип — long long sum и static_cast<long long>(a[i]) * a[i].

0 (ложь). В смешанном сравнении int преобразуется к unsigned, поэтому -1 становится огромным значением (UINT_MAX), которое не меньше 1. Эта ловушка обычных арифметических преобразований ломает и for (size_t i = v.size() - 1; i >= 0; --i).

typedef/alias даёт новое имя, но не новый тип: typedef int UserId; позволяет смешивать UserId и OrderId. Strong typedef оборачивает тип в отдельный класс: struct UserId { int v; }; (или boost::strong_typedef). В C++ нет родного синтаксиса — идиома через композицию.

Агрегат — это массив или класс без объявленных пользователем конструкторов, без приватных нестатических членов-данных и без виртуальных функций. Brace-инициализация заполняет члены в порядке объявления; пропущенные хвостовые члены инициализируются значением. C++20 добавляет назначенные инициализаторы (.x = 1).

Ссылка становится висячей, когда объект, с которым она связана, уничтожается, пока ссылка ещё жива — её использование является неопределённым поведением. Привязка const T& к временному объекту продлевает его до области видимости ссылки. Но продление применяется только к прямой привязке: возврат ссылки её не продлевает.

Правило строгого алиасинга гласит, что к хранимому значению можно обращаться только через lvalue его собственного типа, совместимого типа или char. Чтение float через int* — неопределённое поведение, поэтому оптимизатор считает, что такие указатели не пересекаются, и может переупорядочить или выбросить чтения. Безопасные инструменты — std::memcpy и std::bit_cast.

ASCII — 7-битная кодировка, 128 символов. Unicode назначает кодовые точки каждому символу; UTF-8 — переменная 1–4 байта, совместим с ASCII, UTF-16 — 2 или 4 байта.

Шесть побитовых: & (И), | (ИЛИ), ^ (XOR), ~ (НЕ), <</>> (сдвиги). Булева алгебра: тождества И/ИЛИ/НЕ (де Морган: ~(A & B) == ~A | ~B). Идиомы: установка x |= 1 << n, сброс x &= ~(1 << n), проверка (x >> n) & 1.

Тривиальный тип имеет предоставленные компилятором, невиртуальные специальные функции — никакой пользовательской логики при копировании или разрушении. Только тривиально копируемые типы можно memcpy: побайтовая копия даёт валидный объект, так как нет инвариантов для сохранения. memcpy для std::string — неопределённое поведение.