C++98 was the first ISO standard (1998, with a minor 2003 revision fixing defects), but the language changed relatively little until C++11 — a genuinely transformative release adding auto type deduction, lambda expressions, move semantics, smart pointers, and range-based for loops, informally treated as the dividing line between "old" and "modern" C++. Since then, the committee has shipped a new standard roughly every three years: C++14 (small refinements), C++17 (structured bindings, std::optional), C++20 (concepts, ranges, coroutines, modules), C++23 (std::expected, deducing this), and C++26 — officially published in March 2026 and the current standard — which adds compile-time reflection, contracts, and std::execution for standardized async programming.
C++11: the "second birth" of the language
Compare pre-C++11 code to its modern equivalent — the difference in both safety and readability is exactly why C++11 is treated as such a major dividing line.
std::vector<int> myVector = {1, 2, 3};
// pre-C++11
std::vector<int>::iterator it = myVector.begin();
for (it = myVector.begin(); it != myVector.end(); ++it) { /* ... */ }
int* raw = new int(5);
delete raw; // must remember, every single time
// C++11 and later
auto it2 = myVector.begin(); // auto: type deduced automatically
for (auto& x : myVector) { /* ... */ } // range-based for loop
auto smart = std::make_unique<int>(5); // smart pointer — no manual delete neededThe steady three-year cadence since C++11
Each release since C++11 has shipped roughly every three years, a deliberate, predictable cadence that replaced the much longer, less predictable gaps of the pre-C++11 era (nine years passed between C++98 and C++11).
std::map<std::string, int> myMap = {{"a", 1}};
// C++17: structured bindings
auto [key, value] = *myMap.begin(); // destructure a pair directly
// C++20: concepts constrain a template parameter directly, with a readable error on mismatch
template <std::integral T>
T add(T a, T b) { return a + b; }
// C++23: std::expected for explicit, typed error handling without exceptions
std::expected<int, std::string> parse(const std::string& s);C++26: the current standard, published March 2026
Static reflection — letting code introspect types and functions at compile time — has been called one of the most significant additions to the language's metaprogramming capabilities in years, alongside contracts (formal preconditions/postconditions checked by the compiler) and std::execution, a standardized framework for asynchronous execution that aims to reduce reliance on third-party async libraries.