A short history of C++, from C with Classes to C++26
C++ is old enough to have a history worth telling and young enough that the person who started it still turns up at the standards meetings. This is the short version, with dates you can check against the ISO C++ committee's own status page and Bjarne Stroustrup's The Design and Evolution of C++.
1979: C with Classes
Bjarne Stroustrup joined Bell Labs in 1979 after a PhD at Cambridge where he had written a distributed-systems simulator in Simula. Simula's classes made the program easy to reason about; its run-time made it too slow to use. C was fast and portable but had no way to express the structure. His answer was C with Classes: a preprocessor (Cpre) that added classes, derived classes, constructors and destructors, access control and inline functions to C, and emitted plain C for the existing compiler.
Two decisions from that first year still define the language: you don't pay for what you don't use, and anything expressible in C should remain expressible, at the same cost, in the new language.
1983–1989: Cfront and a new name
In 1983 the language was renamed C++ (Rick Mascitti's joke: the increment operator applied to C) and gained virtual functions, function and operator overloading, references, const and the // comment borrowed from BCPL. The preprocessor became Cfront, a real compiler front-end that still generated C as its output. Release 1.0 shipped in 1985 alongside the first edition of The C++ Programming Language.
Release 2.0 in 1989 added multiple inheritance, abstract classes, static and const member functions and protected members. By then C++ had escaped Bell Labs: commercial compilers existed, and the lack of a formal specification was becoming a problem.
The 1990s: templates, exceptions and the STL
The Annotated C++ Reference Manual (1990) served as the de-facto standard while ANSI, then ISO, formed committees. Two features arrived that turned out to matter more than anyone expected: templates and exceptions (both in Cfront 3.0, 1991). Templates were designed for type-safe containers; in 1994 Alexander Stepanov and Meng Lee showed the committee the Standard Template Library, built on generic algorithms and iterators, and it was voted into the draft standard almost as-is. Namespaces, RTTI, bool and the _cast operators followed.
1998 and 2003: the first standards
ISO/IEC 14882:1998 was the first international standard. C++03 (2003) was a bug-fix release. The language then spent a decade with a widely used but frozen specification, while libraries such as Boost explored what the next version might contain: smart pointers, function objects, threads, regular expressions.
2011: a language that "feels like a new language"
C++11 (originally nicknamed C++0x because it was meant to ship before 2010) was the largest change in the language's history: auto, lambdas, range-based for, rvalue references and move semantics, constexpr, nullptr, scoped enums, uniform initialisation, variadic templates, a memory model and standard threads, std::unique_ptr, std::shared_ptr, std::unordered_map and much more. Stroustrup's description was that it "feels like a new language", and most of the coding style you see in modern codebases dates from here.
The three-year train
After the eight-year gap, the committee moved to a fixed schedule: a standard every three years, with features that aren't ready waiting for the next one.
| Standard | Headline features |
|---|---|
| C++14 | generic lambdas, return type deduction, relaxed constexpr, std::make_unique |
| C++17 | structured bindings, if constexpr, std::optional/variant/any, std::string_view, parallel algorithms, <filesystem>, class template argument deduction |
| C++20 | concepts, ranges, modules, coroutines, <format>, three-way comparison <=>, std::span, calendars and time zones |
| C++23 | std::expected, std::print, std::mdspan, deducing this, std::generator, import std; |
C++26 and beyond
The C++26 draft is feature-complete as of 2025 and heading for publication. Its big-ticket items are static reflection (finally letting code inspect its own types at compile time), contracts (pre- and post-conditions checked by the implementation), std::execution for asynchronous work, a standard linear algebra library and hardened standard-library modes aimed at memory safety. Whether the language can address safety concerns without giving up its first principle, you don't pay for what you don't use, is the argument the next decade will be about.
Sources
- B. Stroustrup, The Design and Evolution of C++, Addison-Wesley, 1994; and "Thriving in a crowded and changing world: C++ 2006–2020", HOPL IV, 2020.
- isocpp.org: Current status of the C++ standard
- cppreference: compiler support tables
Comments 0
Log in or register to join the conversation.
No comments yet.