Особенности и расширения языка C++

ОБЯЗАТЕЛЬНОДЛЯ НОВИЧКОВ

Разработчику Архитектору

Как читать эту тему без перегруза

Если материал кажется "слишком академическим", используйте практический порядок:

Сначала закрепите базу по C++: C++ - язык системного программирования, Типы данных в C++, Переменные и области видимости в C++, Управление памятью в C++.
Затем возьмите одну прикладную цель: "безопасная работа с памятью" или "ускорить сборку".
После этого возвращайтесь к углублённым разделам — концепты, модули, модель памяти.

Так вы связываете термины с задачами, а не запоминаете "список фактов".

Практическая карта решений: когда что применять

Ситуация в проекте	Рекомендуемый инструмент	Почему
Частые падения из-за владения памятью	`std::unique_ptr`, RAII, sanitizers	Снижает риск утечек и use-after-free
Долгая сборка из-за множества заголовков	C++20 modules / precompiled headers	Меньше повторного парсинга
Непонятные ошибки шаблонов	concepts (`requires`)	Ошибки становятся читаемыми
Гонки в многопоточности	`std::mutex` + `lock_guard` (по умолчанию)	Предсказуемость важнее микрооптимизаций
Критичный hot path	профилирование (`perf`, VTune, Tracy) + точечная оптимизация	Оптимизируем по данным, а не по догадкам
ABI-совместимый плагин	C-граница через `extern "C"` + PIMPL	Стабильнее на длительном горизонте

Мини-план роста C++-разработчика

Этап 1. Надёжность

RAII, unique_ptr, корректные деструкторы;
clang-tidy, ASan/UBSan в CI;
убрать "магические" состояния и неявное владение.

Этап 2. Выразительность

STL-алгоритмы и ranges: Стандартные и сторонние библиотеки C++, Диапазоны и представления в C++20;
понятные шаблоны + concepts;
чёткие API и контракты.

Этап 3. Производительность

профилирование на реальных сценариях;
анализ аллокаций и конкуренции потоков;
оптимизация только измеренных узких мест.

Типичные ошибки на практике

Слишком ранний уход в сложность. Переход к lock-free и template-метапрограммированию до того, как решены базовые проблемы кода.
Оптимизация без замеров. Изменения "на глаз" часто ухудшают поддержку и не дают прироста.
Смешение ABI. Разные версии компилятора и стандартной библиотеки в одном продукте.
Неполная стратегия ошибок. Часть кода на исключениях, часть на кодах возврата, без единых правил.

Связанные материалы энциклопедии

База языка и типы: C++ - язык системного программирования, Типы данных в C++, Переменные и области видимости в C++
Память, ресурсы, владение: Управление памятью в C++, Идиомы современного C++
Шаблоны и обобщения: Работа с типами, Диапазоны и представления в C++20
Сборка и инструменты: Конфигурация и сборка в C++, CMake — первая программа, Google Test и Catch2 в C++, Практические задания по C++

Особенности и расширения языка C++

Многопарадигмальность

C++ поддерживает несколько парадигм программирования, что позволяет выбирать наиболее подходящий стиль в зависимости от задачи:

Процедурное программирование: организация кода в виде функций и процедур, последовательно выполняющих действия. Это базовый уровень, унаследованный от языка C.
Объектно-ориентированное программирование (ООП) — инкапсуляция данных и методов в классах, наследование, полиморфизм через виртуальные функции. C++ реализует ООП без обязательной "всё есть объект" философии, сохраняя легковесность.
Обобщённое (шаблонное) программирование — написание кода, независимого от конкретных типов, с автоматической генерацией специализированных версий во время компиляции. Шаблоны C++ являются Тьюринг-полным языком внутри компилятора.
Функциональное программирование — поддержка лямбда-выражений, замыканий, функциональных объектов (std::function, std::bind), неизменяемых структур данных и алгоритмов из <algorithm>.
Метапрограммирование: выполнение вычислений и принятие решений на этапе компиляции с помощью шаблонов (до C++11) и constexpr/consteval (начиная с C++11 и C++20).

Эта гибкость позволяет разработчику использовать комбинацию подходов — например, писать высокоуровневую логику с использованием STL и алгоритмов, а критические участки — на процедурном уровне с прямым управлением памятью.

Управление памятью

C++ предоставляет разработчику прямой контроль над динамической памятью, что является одной из ключевых особенностей языка.

Ручное управление

Операторы new и delete (а также new[] / delete[]) позволяют выделять и освобождать память в куче.
Отсутствие встроенного сборщика мусора означает, что разработчик сам отвечает за корректное освобождение ресурсов.
Возможны утечки памяти, двойное освобождение, использование после освобождения — классические ошибки, требующие внимательности.

RAII (Resource Acquisition Is Initialization)

RAII — идиома, при которой владение ресурсом (памятью, файловым дескриптором, сокетом и т.д.) привязывается к времени жизни объекта.
При создании объекта ресурс захватывается в конструкторе, при уничтожении — освобождается в деструкторе.
Гарантирует автоматическое освобождение ресурсов даже при возникновении исключений.

Умные указатели

Начиная с C++11, стандартная библиотека предоставляет умные указатели, реализующие RAII для динамической памяти:

std::unique_ptr<T> — единоличное владение объектом; не может быть скопирован, только перемещён.
std::shared_ptr<T> — совместное владение через подсчёт ссылок; память освобождается, когда счётчик достигает нуля.
std::weak_ptr<T> — не владеющий наблюдатель за shared_ptr, предотвращающий циклические зависимости.

Эти инструменты позволяют писать безопасный код без явных вызовов delete, сохраняя при этом производительность и предсказуемость.

Шаблоны и обобщённое программирование

Шаблоны — одна из самых мощных особенностей C++. Они позволяют писать код, параметризованный типами или значениями.

Функциональные и классовые шаблоны

template<typename T>
T max(T a, T b) {
    return (a > b) ? a : b;
}

template<typename Key, typename Value>
class Map {
    // реализация контейнера
};

Разбор:

Функция max — шаблонная, поэтому компилятор создаёт отдельные версии для каждого используемого типа T.
Выражение (a > b) ? a : b использует тернарный оператор и возвращает большее значение без лишних веток кода.
Шаблон класса Map<Key, Value> показывает обобщённый контейнер, где тип ключа и значения задаётся при инстанцировании.
Ключевое слово template<typename ...> делает API гибким и пригодным для повторного использования.
Такой подход уменьшает дублирование логики и сохраняет статическую типобезопасность во время компиляции.

Специализация шаблонов

Можно предоставлять специфичные реализации для определённых типов:

template<>
class Map<std::string, int> {
    // оптимизированная версия для строковых ключей
};

Разбор:

Это явная специализация шаблона: для пары типов std::string и int предоставляется отдельная реализация.
Конструкция template<> говорит компилятору, что используется не общий шаблон, а особый вариант под конкретный кейс.
Специализацию применяют, когда для конкретных типов можно сделать более быстрый или функциональный код.
Механизм позволяет точечно оптимизировать горячие сценарии без изменения общего интерфейса шаблона.
В результате пользователь всё так же пишет Map<std::string, int>, но получает специализированное поведение.

SFINAE и концепции

До C++20 использовался механизм SFINAE (Substitution Failure Is Not An Error) для условной компиляции шаблонов.
Начиная с C++20 появились концепции (concepts) — способ задавать требования к типам:

template<std::integral T>
T add(T a, T b) {
    return a + b;
}

Разбор:

Концепт std::integral ограничивает допустимые типы и разрешает вызов только для целочисленных T.
Это упрощает диагностику: при неподходящем типе ошибка возникает на уровне требований шаблона, а не глубоко в теле функции.
Сигнатура сразу выражает контракт функции add, что повышает читаемость публичного API.
Возврат a + b остаётся обычной операцией, но теперь она защищена от случайного использования с неподдерживаемыми типами.
Такой стиль характерен для современного C++20-кода с явными ограничениями на шаблонные параметры.

Концепции делают сообщения об ошибках понятнее и код выразительнее.

Шаблоны переменных и псевдонимов

C++14 добавил шаблоны переменных:

template<typename T>
constexpr bool is_integral_v = std::is_integral<T>::value;

Разбор:

Это шаблонная переменная, которая вычисляет булев признак "тип является целочисленным" для любого T.
constexpr гарантирует вычисление на этапе компиляции и позволяет использовать значение в if constexpr и static_assert.
Суффикс _v — распространённая форма удобного алиаса поверх метафункций std::is_*::value.
Такой шаблон уменьшает шаблонный шум и делает метапрограммирование заметно читаемее.
Пример показывает эволюцию C++14 к более компактной записи type-traits.
C++11 ввёл using для создания шаблонных псевдонимов:

template<typename T>
using Vec = std::vector<T, MyAllocator<T>>;

Разбор:

Алиас using Vec = ... задаёт короткое имя для параметризованного std::vector с пользовательским аллокатором.
При подстановке типа T компилятор формирует конкретный контейнер std::vector<T, MyAllocator<T>>.
Такой псевдоним централизует выбор аллокатора и убирает повторение длинного типа по коду.
Изменение политики памяти теперь делается в одном месте, а не в каждом использовании контейнера.
Это хороший пример того, как шаблонные алиасы упрощают архитектурные решения в больших проектах.

Шаблоны лежат в основе всей Standard Template Library (STL) — контейнеров, алгоритмов, итераторов — обеспечивая высокую производительность за счёт мономорфизации (генерации отдельного кода для каждого типа).

Перегрузка операторов

C++ позволяет переопределять поведение встроенных операторов (+, -, <<, [], () и др.) для пользовательских типов. Это даёт возможность создавать интуитивно понятные интерфейсы.

Пример:

class Complex {
    double re, im;
public:
    Complex operator+(const Complex& other) const {
        return Complex(re + other.re, im + other.im);
    }

    Complex& operator+=(const Complex& other) {
        re += other.re;
        im += other.im;
        return *this;
    }
};

Разбор:

Класс Complex демонстрирует перегрузку арифметических операторов для пользовательского числового типа.
operator+ объявлен как const и возвращает новый объект, поэтому операция не изменяет текущий экземпляр.
operator+= изменяет состояние текущего объекта и возвращает *this, что поддерживает цепочки присваивания.
Такой набор обычно реализуют парой: + для создания значения, += для эффективного обновления на месте.
Код подчёркивает правило "операторы должны вести себя ожидаемо", иначе API становится трудно предсказуемым.

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

operator<< и operator>> для потокового ввода-вывода (std::cout << obj);
operator[] для контейнеров (vec[0]);
operator() для функторов и лямбд;
operator* и operator-> для итераторов и умных указателей.

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

Исключения и безопасность исключений

C++ поддерживает механизм исключений через try, catch, throw. Однако в системном программировании и встраиваемых системах исключения часто отключаются (-fno-exceptions), так как они увеличивают размер кода и снижают предсказуемость производительности.

Для обеспечения корректности при наличии исключений используются гарантии безопасности исключений:

No-throw guarantee: операция никогда не выбрасывает исключение.
Strong exception safety: если исключение произошло, состояние программы остаётся как до вызова.
Basic exception safety: программа остаётся в валидном состоянии, но изменения могут быть частичными.

RAII и умные указатели играют ключевую роль в обеспечении этих гарантий.

Атрибуты и расширения компиляторов

Хотя C++ стремится к переносимости, реальная разработка часто требует использования расширений.

Стандартные атрибуты (C++11 и новее)

[[nodiscard]] — предупреждает, если возвращаемое значение игнорируется.
[[deprecated]] — помечает устаревший код.
[[maybe_unused]] — подавляет предупреждения о неиспользуемых переменных.
[[noreturn]] — функция никогда не возвращается (например, exit).

Расширения компиляторов

GCC/Clang:
- __attribute__((packed)) — упаковка структур без выравнивания.
- __builtin_expect — подсказка ветвлению (likely/unlikely).
- __thread — thread-local storage.
MSVC:
- __declspec(dllexport) / dllimport — экспорт/импорт из DLL.
- #pragma pack — управление выравниванием.
- __forceinline — агрессивное встраивание функций.

Хотя такие расширения нарушают переносимость, они необходимы для взаимодействия с ОС, драйверами, низкоуровневыми API.

Поддержка многопоточности

Начиная с C++11, язык получил встроенную поддержку многопоточности:

std::thread — управление потоками.
std::mutex, std::lock_guard, std::unique_lock — синхронизация.
std::atomic — атомарные операции без блокировок.
std::future / std::promise — асинхронные вычисления.
std::async — запуск функций асинхронно.

Это позволило писать переносимый многопоточный код без прямого использования POSIX threads или Windows API.

constexpr-программирование и вычисления на этапе компиляции

C++ предоставляет мощные средства для выполнения вычислений ещё до запуска программы. Это позволяет сократить время выполнения, уменьшить объём генерируемого кода и повысить безопасность.

`constexpr` (начиная с C++11)

Ключевое слово constexpr указывает, что значение или функция могут быть вычислены на этапе компиляции при наличии константных аргументов.

constexpr int square(int x) {
    return x * x;
}

constexpr int val = square(5); // вычисляется во время компиляции

Функции, помеченные как constexpr, должны:

содержать только одно выражение return (в C++11);
не иметь побочных эффектов;
оперировать только над типами, допустимыми в контексте времени компиляции.

Начиная с C++14, ограничения ослабли — разрешены локальные переменные, циклы, условные операторы.

`consteval` (C++20)

Гарантирует, что функция всегда вызывается на этапе компиляции:

consteval int factorial(int n) {
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

Попытка вызвать такую функцию с неконстантным аргументом приведёт к ошибке компиляции.

`constinit` (C++20)

Обеспечивает статическую инициализацию переменной, предотвращая динамическую инициализацию и связанные с ней проблемы порядка инициализации:

constinit int global_counter = 42; // инициализируется до main()

Эти механизмы позволяют реализовывать сложную логику — например, парсинг строк, генерацию таблиц хэшей, проверку инвариантов — полностью на этапе компиляции.

Move-семантика и управление ресурсами

Одно из ключевых усовершенствований C++11 — move-семантика, которая позволяет передавать владение ресурсами без копирования.

R-value ссылки

Специальный тип ссылки (T&&) обозначает временный объект, которым можно "владеть":

std::vector<int> create_vector() {
    return std::vector<int>{1, 2, 3}; // временный объект
}

std::vector<int> v = create_vector(); // move, а не copy

Move-конструктор и move-оператор присваивания

Класс может определить специальные методы для передачи ресурсов:

Код ITЗагрузка примера кода…

Move-семантика делает возможным эффективную передачу больших объектов (векторов, строк, файловых потоков) без аллокаций памяти и копирования данных.

Perfect forwarding

С помощью std::forward и универсальных ссылок (T&& в шаблонах) можно передавать аргументы в другие функции, сохраняя их категорию (l-value или r-value):

template<typename T>
void wrapper(T&& arg) {
    process(std::forward<T>(arg)); // передаёт как есть
}

Это основа для эффективных фабрик, контейнеров и функциональных обёрток.

CRTP (Curiously Recurring Template Pattern)

CRTP — идиома, при которой класс наследуется от шаблонного базового класса, параметризованного самим производным классом:

Код ITЗагрузка примера кода…

Преимущества:

статический полиморфизм без виртуальных вызовов;
возможность добавлять общую функциональность (например, операторы сравнения, сериализацию) через наследование;
нулевые накладные расходы во время выполнения.

CRTP широко используется в библиотеках, таких как Eigen (линейная алгебра) и Boost.

Policy-Based Проектирование

Подход, предложенный Александреску в книге "Modern C++ Проектирование", заключается в параметризации поведения класса через шаблонные аргументы — "политики":

Код ITЗагрузка примера кода…

Этот стиль обеспечивает:

высокую гибкость и повторное использование кода;
композицию на этапе компиляции;
возможность комбинировать поведения без наследования.

Policy-based Проектирование лежит в основе многих современных библиотек, включая стандартную библиотеку (например, аллокаторы в контейнерах).

ABI (Application Binary Interface) и совместимость

ABI определяет, как скомпилированные единицы кода взаимодействуют на уровне машинных инструкций:

манглинг имён функций;
порядок передачи аргументов;
выравнивание структур;
обработка исключений;
представление виртуальных таблиц.

В отличие от API, ABI нестабилен между версиями компиляторов. Например, GCC 4 и GCC 13 могут генерировать несовместимые бинарники.

Для обеспечения стабильности ABI в библиотеках часто используют:

чистые виртуальные интерфейсы ("pimpl" + абстрактный базовый класс);
экспортируемые функции в стиле C (extern "C");
явное управление макетом структур (#pragma pack, alignas).

Inline assembly и низкоуровневый контроль

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

int a = 5, b = 10, result;
asm("addl %%ebx, %%eax"
    : "=a"(result)        // выход
    : "a"(a), "b"(b)      // вход
    :                     // разрушаемые регистры
);

Хотя это нарушает переносимость, inline assembly необходим для:

криптографических примитивов (AES-NI, SHA);
атомарных операций на старых архитектурах;
профилирования через счётчики производительности.

Современные компиляторы предоставляют встроенные функции (__builtin_...), которые безопаснее и портируемее.

Взаимодействие с C

C++ сохраняет обратную совместимость с C на уровне вызова функций:

extern "C" {
    #include "legacy_c_library.h"
}

Конструкция extern "C" отключает манглинг имён, позволяя C++ коду вызывать C-функции и наоборот. Это критически важно для:

использования системных библиотек (POSIX, Windows API);
интеграции с legacy-кодом;
создания бинарно-совместимых плагинов.

Однако полная семантическая совместимость невозможна — C++ поддерживает исключения, перегрузку, шаблоны — чего нет в C.

Современные тренды в C++20/C++23

Модули (Modules)

Заменяют #include механизмом импорта, ускоряя компиляцию и устраняя проблемы с макросами и порядком включения:

// math.mpp
export module math;
export int add(int a, int b) { return a + b; }

// main.cpp

import math;

int x = add(2, 3);

Концепции (Concepts)

Позволяют задавать требования к шаблонным параметрам:

template<std::integral T>
T gcd(T a, T b) {
    while (b != 0) {
        T t = b;
        b = a % b;
        a = t;
    }
    return a;
}

Компилятор выдаст понятную ошибку, если тип не удовлетворяет концепции.

Coroutines

Поддержка асинхронного программирования на уровне языка:

task<int> fetch_data() {
    auto result = co_await http_get("https://api.example.com");
    co_return parse(result);
}

Coroutines используются в сетевых библиотеках, игровых движках, реактивных системах.

Range-based алгоритмы

Стандартная библиотека теперь работает с диапазонами, а не парами итераторов:

std::vector<int> v = {1, 2, 3, 4, 5};
auto evens = v | std::views::filter([](int x) { return x % 2 == 0; })
               | std::views::transform([](int x) { return x * x; });

Это делает код более выразительным и композируемым.

Внутреннее устройство стандартной библиотеки

Стандартная библиотека C++ (Standard Library) — неотъемлемая часть языка, предоставляющая готовые решения для повседневных задач. Её архитектура построена на трёх китах: контейнеры, алгоритмы и итераторы.

Контейнеры

Контейнеры делятся на три категории:

Последовательные — std::vector, std::deque, std::list, std::forward_list. Хранят элементы в определённом порядке.
Ассоциативные — std::set, std::map, std::multiset, std::multimap. Обеспечивают упорядоченное хранение по ключу с логарифмической сложностью операций.
Неупорядоченные (хэш-таблицы): std::unordered_set, std::unordered_map и их мультиверсии. Используют хэширование для константного времени доступа в среднем случае.

Все контейнеры параметризованы типом элемента и аллокатором памяти, что позволяет адаптировать их под специфичные требования (например, выделение памяти из пула).

Алгоритмы

Алгоритмы (<algorithm>) работают через итераторы и не зависят от конкретного типа контейнера:

std::vector<int> v = {5, 2, 8, 1};
std::sort(v.begin(), v.end());

Это обеспечивает высокую переиспользуемость и композируемость. Алгоритмы могут быть:

модифицирующими (std::transform, std::replace);
немодифицирующими (std::find, std::count);
разделяющими (std::partition);
упорядочивающими (std::sort, std::partial_sort).

Начиная с C++17, многие алгоритмы получили параллельные версии через execution policies:

std::sort(std::execution::par_unseq, v.begin(), v.end());

Итераторы

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

входные / выходные;
однонаправленные;
двунаправленные;
произвольного доступа.

Эта система позволяет компилятору выбирать наиболее эффективную реализацию алгоритма в зависимости от возможностей итератора.

SIMD и векторизация

C++ предоставляет средства для использования SIMD (Single Instruction, Multiple Data) — технологии, позволяющей выполнять одну инструкцию над несколькими данными одновременно.

Векторизация компилятором

Современные компиляторы автоматически векторизуют циклы при определённых условиях:

отсутствие зависимостей между итерациями;
регулярный доступ к памяти;
использование простых арифметических операций.

Флаги вроде -O3 -march=native активируют эту оптимизацию.

Явное использование SIMD

Для максимального контроля можно использовать:

интринсики (<immintrin.h>): функции вроде _mm256_add_ps для AVX;
библиотеки — Eigen, Vc, std::simd (в C++26);
OpenMP SIMD directives.

Пример с AVX:

#include <immintrin.h>
void add_arrays(float* a, float* b, float* c, size_t n) {
    for (size_t i = 0; i < n; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vc = _mm256_add_ps(va, vb);
        _mm256_store_ps(&c[i], vc);
    }
}

Это критически важно в HPC, обработке изображений, игровых движках.

Как читать эту тему без перегруза​

Практическая карта решений: когда что применять​

Мини-план роста C++-разработчика​

Типичные ошибки на практике​

Связанные материалы энциклопедии​

Особенности и расширения языка C++​

Многопарадигмальность​

Управление памятью​

Ручное управление​

RAII (Resource Acquisition Is Initialization)​

Умные указатели​

Шаблоны и обобщённое программирование​

Функциональные и классовые шаблоны​

Специализация шаблонов​

SFINAE и концепции​

Шаблоны переменных и псевдонимов​

Перегрузка операторов​

Исключения и безопасность исключений​

Атрибуты и расширения компиляторов​

Стандартные атрибуты (C++11 и новее)​

Расширения компиляторов​

Поддержка многопоточности​

constexpr-программирование и вычисления на этапе компиляции​

constexpr (начиная с C++11)​

consteval (C++20)​

constinit (C++20)​

Move-семантика и управление ресурсами​

R-value ссылки​

Move-конструктор и move-оператор присваивания​

Perfect forwarding​

CRTP (Curiously Recurring Template Pattern)​

Policy-Based Проектирование​

ABI (Application Binary Interface) и совместимость​

Inline assembly и низкоуровневый контроль​

Взаимодействие с C​

Современные тренды в C++20/C++23​

Модули (Modules)​

Концепции (Concepts)​

Coroutines​

Range-based алгоритмы​

Внутреннее устройство стандартной библиотеки​

Контейнеры​

Алгоритмы​

Итераторы​

SIMD и векторизация​

Векторизация компилятором​

Явное использование SIMD​

См. также

C++ - язык системного программирования

Экосистема приложений на C++

Что требуется знать перед началом изучения языка программирования C++

Первая программа на C++

Начало работы с C++

Конфигурация и сборка в C++

Простые приложения на C++

CMake — первая программа

Google Test и Catch2 в C++

Практические задания по C++

Рекомендации по разработке на C++

Типы данных в C++

Как читать эту тему без перегруза

Практическая карта решений: когда что применять

Мини-план роста C++-разработчика

Типичные ошибки на практике

Связанные материалы энциклопедии

Особенности и расширения языка C++

Многопарадигмальность

Управление памятью

Ручное управление

RAII (Resource Acquisition Is Initialization)

Умные указатели

Шаблоны и обобщённое программирование

Функциональные и классовые шаблоны

Специализация шаблонов

SFINAE и концепции

Шаблоны переменных и псевдонимов

Перегрузка операторов

Исключения и безопасность исключений

Атрибуты и расширения компиляторов

Стандартные атрибуты (C++11 и новее)

Расширения компиляторов

Поддержка многопоточности

constexpr-программирование и вычисления на этапе компиляции

`constexpr` (начиная с C++11)

`consteval` (C++20)

`constinit` (C++20)

Move-семантика и управление ресурсами

R-value ссылки

Move-конструктор и move-оператор присваивания

Perfect forwarding

CRTP (Curiously Recurring Template Pattern)

Policy-Based Проектирование

ABI (Application Binary Interface) и совместимость

Inline assembly и низкоуровневый контроль

Взаимодействие с C

Современные тренды в C++20/C++23

Модули (Modules)

Концепции (Concepts)

Coroutines

Range-based алгоритмы

Внутреннее устройство стандартной библиотеки

Контейнеры

Алгоритмы

Итераторы

SIMD и векторизация

Векторизация компилятором

Явное использование SIMD