Стандарты C++

Эволюция языка от C++11 до C++26 — move-семантика, `auto`, лямбды, концепты, корутины, модули, ranges, `std::expected` и предстоящие фичи.

IT Abyss

Стандарты C++ — что добавляли и зачем

С C++11 язык кардинально изменился: то, что раньше требовало шаблонной магии или сторонних библиотек, переехало в стандарт. Каждые три года выходит новый стандарт; знать, что в каком стандарте появилось, — это и про переносимость кода, и про подбор инструментов под задачу.

Карта темы

C++11 — move-семантика, auto, лямбды, smart pointers, nullptr, constexpr, потоки.
C++14 — generic-лямбды, return-type deduction, ослабленный constexpr, std::make_unique.
C++17 — structured bindings, if constexpr, std::optional, std::string_view, fold expressions, parallel STL.
C++20 — концепты, корутины, модули, ranges, <=>, std::span, std::format.
C++23 — std::expected, std::print, std::mdspan, deducing this, std::generator.
C++26 (в работе) — рефлексия, контракты, senders/receivers, std::execution.

C++11 — революция

Самый крупный сдвиг в истории языка. Что появилось:

Move-семантика: rvalue-ссылки T&&, std::move. Передача владения без копирования. Базис для std::unique_ptr и эффективных контейнеров.
auto: вывод типа компилятором. Спас от std::vector<std::map<std::string, int>>::const_iterator.
Лямбды: [](int x) { return x * 2; }. Локальные функции с захватом контекста.
Smart pointers: std::unique_ptr, std::shared_ptr, std::weak_ptr. RAII для динамической памяти.
nullptr: типобезопасный заменитель макроса NULL.
constexpr: вычисления во время компиляции (в C++11 — только один return).
Threading: std::thread, std::mutex, std::atomic. Первая стандартная многопоточность.
Range-based for: for (auto x : container).
Variadic templates: template<typename... Ts>.

C++14 — полировка

«Bug fix release» — закрыл дыры C++11:

Generic lambdas: [](auto x) { ... }.
Return type deduction для обычных функций: auto foo() { return 42; }.
Ослабленный constexpr: можно if, for, локальные переменные.
std::make_unique — забыли в C++11.
Binary literals: 0b1010.

C++17 — практичные фичи

Structured bindings: auto [k, v] = *map.begin();.
if constexpr: ветвление шаблонов без SFINAE.
std::optional, std::variant, std::any — вне-стандартные ранее vocabulary types.
std::string_view — non-owning view на строку. Дешёвая передача без копий.
Fold expressions: (args + ...) — variadic-аргументы в один выражение.
Parallel STL: std::execution::par для std::sort и других алгоритмов.
std::filesystem — стандартизированный API для путей.

⚠️ std::string_view не владеет данными — хранение его дольше source-строки — UB.

C++20 — второй мегарелиз

Размером сравним с C++11:

Concepts: типобезопасные ограничения на шаблоны вместо SFINAE.

  template<std::integral T>
  T square(T x) { return x * x; }

Coroutines: co_await, co_yield, co_return. Языковая поддержка stackless-корутин.
Modules: import std; вместо #include. Решают проблемы заголовков (макросы, повторный парсинг).
Ranges: views::filter, views::transform, ленивые композиции вместо итераторных пар.
<=> (spaceship): автогенерируемые операторы сравнения.
std::span — non-owning view на массив (как string_view, но для произвольного типа).
std::format — type-safe форматирование (наконец-то).
constinit, consteval, расширенный constexpr (теперь почти везде).

⚠️ Поддержка C++20 в компиляторах и системах сборки до сих пор неполная — особенно модули. Большинство продакшен-проектов в 2026 — на C++17.

C++23 — следующий шаг

std::expected<T, E> — value-or-error без исключений, как Rust Result.
std::print — наконец print("Hello {}", name);.
std::mdspan — многомерный non-owning view (для научных вычислений и ML).
Deducing this: template<typename Self> auto foo(this Self&& self). Унификация const/non-const overloads.
std::generator — coroutine-based генератор для синтаксиса co_yield.

C++26 — на подходе

В работе на момент 2026:

Reflection — статическое отражение типов и членов на этапе компиляции.
Contracts — pre/post/assert-условия в сигнатуре.
Senders/Receivers (std::execution) — структурированный async, замена ad-hoc std::async.
Pattern matching — inspect выражения.

Частые ошибки и ловушки

Ошибка	Последствие
Считать, что C++20 production-ready везде	Модули и корутины ещё с шероховатостями в gcc/clang/msvc
Хранить `std::string_view` дольше source-строки	UB — повисший view
`std::optional<T>` для больших `T` без обдумывания	Стек раздувается; для больших объектов — указатель
Использовать фичу без `__cpp_*` feature-test макроса	Сборка падает на старом компиляторе
C++11 `constexpr` ≠ C++14+ `constexpr`	В C++11 запрещены локальные переменные и ветвления
`auto_ptr` (C++03) в новом коде	Удалён в C++17, заменяется `unique_ptr`
Полагаться на TS/proposal до финального голосования	Фича может измениться или не войти

Значение для собеседований

Знание стандартов — маркер свежести. Junior должен знать минимум C++11 фичи (move, smart pointers, лямбды). Middle должен ориентироваться в C++17 (structured bindings, optional, string_view). Senior — обсуждать C++20/23 (концепты, корутины, expected) и понимать состояние их поддержки.

Типичный неправильный ответ: «std::optional появился в C++20 вместе с концептами» — нет, в C++17.

Популярные направления:

Какие самые важные фичи добавил C++11?
Что появилось в C++17 и зачем нужен std::string_view?
Что добавил C++20 и насколько он production-ready?
Чем std::expected (C++23) отличается от исключений?
Зачем понадобились feature-test макросы?

intermediate

C++ Standards

The evolution of the language from C++11 through C++26 — move semantics, `auto`, lambdas, concepts, coroutines, modules, ranges, `std::expected`, and upcoming features.

Standards

Practice: 2 questions →

Contents

Detailed explanation

C++ Standards — what was added and why

The language changed dramatically with C++11: things that used to require template magic or third-party libraries moved into the standard. A new standard ships every three years; knowing what landed where is partly about portability and partly about picking the right tool for the job.

Topic map

C++11 — move semantics, auto, lambdas, smart pointers, nullptr, constexpr, threads.
C++14 — generic lambdas, return-type deduction, relaxed constexpr, std::make_unique.
C++17 — structured bindings, if constexpr, std::optional, std::string_view, fold expressions, parallel STL.
C++20 — concepts, coroutines, modules, ranges, <=>, std::span, std::format.
C++23 — std::expected, std::print, std::mdspan, deducing this, std::generator.
C++26 (in flight) — reflection, contracts, senders/receivers, std::execution.

C++11 — the revolution

The single largest shift in the language's history. What landed:

Move semantics: rvalue references T&&, std::move. Transfer ownership without copying. The basis for std::unique_ptr and efficient containers.
auto: compiler type deduction. Saved us from std::vector<std::map<std::string, int>>::const_iterator.
Lambdas: [](int x) { return x * 2; }. Local functions with captured context.
Smart pointers: std::unique_ptr, std::shared_ptr, std::weak_ptr. RAII for dynamic memory.
nullptr: type-safe replacement for the NULL macro.
constexpr: compile-time evaluation (C++11 limited it to a single return).
Threading: std::thread, std::mutex, std::atomic. The first standard concurrency model.
Range-based for: for (auto x : container).
Variadic templates: template<typename... Ts>.

C++14 — polish

A "bug-fix release" that filled in C++11's gaps:

Generic lambdas: [](auto x) { ... }.
Return-type deduction for regular functions: auto foo() { return 42; }.
Relaxed constexpr: if, for, local variables are allowed.
std::make_unique — forgotten in C++11.
Binary literals: 0b1010.

C++17 — practical wins

Structured bindings: auto [k, v] = *map.begin();.
if constexpr: template branching without SFINAE.
std::optional, std::variant, std::any — previously third-party vocabulary types.
std::string_view — non-owning view on a string. Cheap to pass without a copy.
Fold expressions: (args + ...) — variadic arguments collapsed into one expression.
Parallel STL: std::execution::par for std::sort and other algorithms.
std::filesystem — a standardized path API.

⚠️ std::string_view does not own its data — outliving the source string is UB.

C++20 — the second mega-release

Comparable in scope to C++11:

Concepts: type-safe template constraints replacing SFINAE.

  template<std::integral T>
  T square(T x) { return x * x; }

Coroutines: co_await, co_yield, co_return. Language support for stackless coroutines.
Modules: import std; instead of #include. Solves header problems (macros, repeated parsing).
Ranges: views::filter, views::transform, lazy composition replacing iterator pairs.
<=> (spaceship): auto-generated comparison operators.
std::span — non-owning view on an array (like string_view, but for any element type).
std::format — type-safe formatting (finally).
constinit, consteval, expanded constexpr (now nearly everywhere).

⚠️ Compiler and build-system support for C++20 is still incomplete — especially modules. Most production code in 2026 is still on C++17.

C++23 — the next step

std::expected<T, E> — value-or-error without exceptions, like Rust's Result.
std::print — finally print("Hello {}", name);.
std::mdspan — multidimensional non-owning view (for scientific and ML code).
Deducing this: template<typename Self> auto foo(this Self&& self). Unifies const/non-const overloads.
std::generator — coroutine-based generator that consumes co_yield.

C++26 — incoming

Targeted as of 2026:

Reflection — static reflection of types and members at compile time.
Contracts — pre / post / assert clauses in the signature.
Senders/Receivers (std::execution) — structured async, replacing ad-hoc std::async.
Pattern matching — inspect expressions.

Common traps

Mistake	Consequence
Assuming C++20 is production-ready everywhere	Modules and coroutines still have rough edges in gcc/clang/msvc
Storing `std::string_view` past the source string's lifetime	UB — dangling view
Putting large `T` inside `std::optional<T>` without thought	Stack bloat; for large objects use a pointer
Using a feature without a `__cpp_*` feature-test guard	Build fails on the older compiler
Confusing C++11 `constexpr` with C++14+ `constexpr`	C++11 forbids local variables and branches
`auto_ptr` (C++03) in new code	Removed in C++17, replaced by `unique_ptr`
Relying on a TS or proposal before final vote	The feature may change or fail to land

Interview relevance

Knowing the standards is a freshness signal. A junior should know the core C++11 features (move, smart pointers, lambdas). A middle should be at ease with C++17 (structured bindings, optional, string_view). A senior should discuss C++20/23 (concepts, coroutines, expected) and understand their support status.

Typical wrong answer: "std::optional shipped in C++20 along with concepts" — no, it shipped in C++17.

Popular question directions:

Which features did C++11 add that matter most?
What did C++17 ship, and why do we need std::string_view?
What did C++20 add, and how production-ready is it?
How does std::expected (C++23) compare to exceptions?
Why do we need feature-test macros?

Why it matters

Modern C++ is a broad phrase, and each standard ships a set of tools with concrete trade-offs. Interviewers expect you to know which feature landed in which standard and why — it's a freshness signal.