skip to content

Which ISO C++ standards have been published since C++98, and what headline features did C++11, C++14 and C++17 bring?

level: juniorimportance: must knowfreq 65%

answer

  1. three-year train since 2011
  2. C++03 fixed defects only
  3. C++11: moves, lambdas, smart pointers
  4. C++14 polished, C++17 added vocabulary types

basics

~20 s

C++98 was followed by C++03 (a defect-fix release), then C++11, C++14, C++17, C++20 and C++23 on a three-year train. C++11 added move semantics, auto, lambdas and smart pointers; C++14 polished them; C++17 added optional, variant, string_view and structured bindings.

solid answer

~40 s

The published revisions are C++98, C++03 (a technical corrigendum with no headline features), C++11, C++14, C++17, C++20 and C++23, which ISO published in 2024; WG21 finished C++26 in 2026. Since C++11 the committee ships on a **three-year train**: what is ready ships, the rest waits. **C++11** is the rewrite people call modern C++: rvalue references and move semantics, `auto`, lambdas, range-`for`, `nullptr`, `constexpr`, variadic templates, `std::unique_ptr` and `std::shared_ptr`, `std::thread` and a memory model. **C++14** finished it: generic lambdas, function return type deduction, `std::make_unique`. **C++17** added `std::optional`, `std::variant`, `std::string_view`, `std::filesystem`, structured bindings, `if constexpr`, fold expressions and guaranteed copy elision, and removed `std::auto_ptr`.

go deeper

for a junior

Recall the order C++98, C++11, C++14, C++17, C++20, C++23 and three headline features of C++11; naming move semantics, lambdas and smart pointers is the usual screen.

for a middle

Place features precisely: generic lambdas and make_unique are C++14, optional and structured bindings C++17. Explain why the three-year train makes small releases like C++14 normal.

for a senior

Connect the timeline to code you maintained: which removals bit you when raising the standard, and which C++17 features replaced in-house utilities or third-party optional and variant types.

for a principal

Treat the revision list as a dependency on toolchains: a standard's year says what the document contains, not what your oldest compiler or standard library already ships.

## The release train C++ is standardised by the ISO committee **WG21**. Each published revision replaces the previous one as *the* C++ standard, and compilers then implement it over several releases. C++98 to C++11 took thirteen years; since C++11 the committee has run a **three-year train**: whatever is finished when the train leaves ships, and a feature that is not ready waits for the next one. That is how C++20's coroutines could ship without a library generator type, with `std::generator` following in C++23. | Revision | `__cplusplus` | Character | |---|---|---| | C++98 | `199711L` | first ISO standard | | C++03 | `199711L` | technical corrigendum: defect fixes, no new headline features | | C++11 | `201103L` | the large rewrite usually called modern C++ | | C++14 | `201402L` | completes C++11 | | C++17 | `201703L` | vocabulary types and template conveniences | | C++20 | `202002L` | concepts, ranges, coroutines, modules | | C++23 | `202302L` | completes C++20; published by ISO in 2024 | | C++26 | `202603L` in the final draft | finished by WG21 in 2026, ISO publication pending | Before a revision's year was known, compilers used provisional flag spellings: `c++0x` for C++11, `c++1y` for C++14, `c++1z` for C++17, `c++2a` for C++20, `c++2b` for C++23 and `c++2c` for C++26. GCC still accepts the old ones and documents them as deprecated, so you will meet `-std=c++1z` in old build files. ## C++11: the release that defined modern C++ C++11 changed how everyday code is written. The features an interviewer expects you to name: - **Rvalue references and move semantics** — containers and strings can hand over their buffers instead of copying them. - **`auto` and `decltype`** — the compiler deduces types. - **Lambdas** and the **range-based `for`** loop. - **`nullptr`**, **`enum class`**, `override` and `final`, `= default` and `= delete`. - **`constexpr`** functions (one return statement only in C++11), **variadic templates** and `static_assert`. - **Smart pointers** `std::unique_ptr` and `std::shared_ptr`, plus the hash containers `std::unordered_map` and `std::unordered_set`. - **`std::thread`, `std::mutex`, `std::atomic`** and a memory model, so threads became part of the language rather than a platform API. ## C++14: finishing C++11 C++14 is a small release that fills the gaps C++11 left: **generic lambdas** (`auto` parameters), **return type deduction** for ordinary functions, **init captures** in lambdas, relaxed `constexpr` (loops and several statements), **variable templates**, binary literals and digit separators (`1'000'000`), and **`std::make_unique`**, which C++11 had left out. ## C++17: vocabulary types and simpler templates C++17 is the baseline most production code builds with today. It brought: - library **vocabulary types**: `std::optional`, `std::variant`, `std::any`, `std::string_view`, plus `std::filesystem` and the parallel algorithms in `<execution>`; - **structured bindings** (`auto [key, value] = pair;`), **`if constexpr`**, **fold expressions** and **class template argument deduction**; - **inline variables**, nested namespace definitions (`namespace a::b {}`) and `if` statements with an initializer; - **guaranteed copy elision** for prvalues and a defined evaluation order for several expressions; - **removals**: `std::auto_ptr`, `std::bind1st`/`bind2nd`, `std::random_shuffle`, the `register` storage class, trigraphs and potentially-throwing dynamic exception specifications such as `throw(std::bad_alloc)`. ## Reading the timeline in an interview A good answer does three things: 1. **Ties each headline to its revision.** "Lambdas are C++11, generic lambdas C++14" shows you have lived through the versions; "lambdas are C++14" is the classic slip. 2. **Knows what was removed**, because removals are what break old code when a team raises its standard: `auto_ptr` code stops compiling under `-std=c++17`. 3. **Separates the standard from the compiler.** A revision is a document; each compiler ships it feature by feature, so "C++17" in a job description means the language mode a team builds with, not a promise that every feature works on every toolchain. ## Where the later revisions fit The same train continued after C++17. **C++20** was the next large release, comparable in scope to C++11: concepts, ranges, coroutines and modules, plus `<=>`, `std::format`, `std::span` and `std::jthread`. **C++23** is a completing release in the spirit of C++14 — `std::expected`, `std::print`, `std::generator` and deducing `this` fill gaps C++20 left — and ISO published it in 2024 as ISO/IEC 14882:2024. **C++26**, finished by WG21 in 2026, adds static reflection, contracts and `std::execution`. In an interview you only need to place these releases on the timeline; each one's features are a topic of their own. One pattern is worth saying out loud because interviewers like it: the large releases (C++11, C++20) are each followed by a smaller one (C++14, C++23) that completes them. The train makes this natural, since a feature that misses the deadline simply arrives three years later.

  • What do flag spellings such as -std=c++1z or -std=c++2b mean?
    They are the provisional names compilers used before a revision's year was fixed: `c++0x` is C++11, `c++1y` C++14, `c++1z` C++17, `c++2a` C++20, `c++2b` C++23 and `c++2c` C++26. GCC still accepts the older ones and documents them as deprecated, so a build file using `-std=c++1z` is simply asking for C++17.
  • What did C++17 remove that older code may still use?
    `std::auto_ptr` (use `std::unique_ptr`), `std::bind1st`, `bind2nd` and `std::random_shuffle`, the `register` storage class, trigraphs, `++` on a `bool`, and potentially-throwing dynamic exception specifications such as `throw(X)`. The empty `throw()` survived as a non-throwing specification until C++20 removed it in favour of `noexcept`.

  • Lambdas and auto were introduced in C++14.
  • C++03 was a feature release on the scale of C++11.
  • std::make_unique arrived together with std::unique_ptr in C++11.
  • std::optional and std::string_view have been standard since C++11.
  • WG21 publishes a new standard only when a big feature is ready.

Assumes C++23 (ISO/IEC 14882:2024) is the latest published standard; C++26 is finished by WG21 but awaits ISO publication.