{"title":"History of C++","description":null,"content":"C++ was born in 1979 inside Bell Labs as a side project to make C feel less painful for large systems work. Almost five decades later, it's gone through several major reinventions, and the version you write today looks very little like the version your senior colleagues learned from a worn-out textbook. This chapter walks through that timeline, from the first \"C with Classes\" prototype to C++23, and explains why knowing the history actually helps you read C++ code in the wild.\n\n---\n\n# Origins at Bell Labs\n\nIn **1979**, a Danish computer scientist named **Bjarne Stroustrup** joined Bell Labs in New Jersey, the same lab that gave the world C, Unix, and the transistor. Stroustrup had just finished his PhD work, where he'd used a language called **Simula** to simulate a distributed software system. Simula was the first language to ship the ideas we now call object-oriented programming: classes, inheritance, virtual functions, the whole package.\n\nSimula was lovely to write in. It was also painfully slow. When Stroustrup tried to use it for serious system-level work at Bell Labs, the runtime overhead made the language unusable for the problems he actually had to solve, things like analyzing the call graph of the Unix kernel and modeling network traffic.\n\nC, on the other hand, was fast. It compiled down to tight machine code, it gave you direct access to memory, and the Unix folks down the hall were happy to help. But C had no classes, no inheritance, no way to bundle data and behavior together. For a project with thousands of interacting modules, organizing the code in plain C was a constant fight.\n\nSo Stroustrup did the obvious thing. He started bolting Simula's class system onto C. The first version, built in 1979 and used internally at Bell Labs, was called **\"C with Classes\"**. It was a preprocessor that translated class-style syntax into plain C, which then went through the regular C compiler. Classes, basic inheritance, inline functions, and access control (`public`, `private`) all date from this era.\n\n---\n\n# The Pre-Standard Era\n\nBy **1983**, \"C with Classes\" had grown enough new features that the name didn't fit anymore. Stroustrup renamed the language to **C++**. The `++` is the C increment operator, so the name literally means \"C, incremented\", a small joke that has aged surprisingly well.\n\nThe first commercial release of C++ came in **1985**, along with Stroustrup's book *The C++ Programming Language*, which served as the de facto specification for years. There was no standards body yet, no ISO committee, just one book and one compiler from AT&T.\n\nOver the next decade, C++ kept growing. **Virtual functions** came in 1983. **Multiple inheritance** arrived in 1989. **Templates** and **exceptions** showed up in 1990. **Namespaces** and the early versions of the **Standard Template Library** (STL) followed in the early 1990s. Each addition made the language more powerful and also a lot harder to learn.\n\nThe problem with this era was that there was no official spec. Different compilers implemented different subsets of the language. Code that compiled on one compiler often failed on another. The community knew this couldn't last.\n\n---\n\n# C++98 and the First Standard\n\nIn **1998**, the **ISO C++ committee** (officially known as ISO/IEC JTC1/SC22/WG21) published the first international standard for the language: **ISO/IEC 14882:1998**, almost always called **C++98**. This was a big deal. For the first time, there was a single document everyone, compiler vendors, library authors, and developers, could point to and say \"this is what C++ means.\"\n\nC++98 locked in the core language you'd recognize today: classes, inheritance, virtual functions, templates, exceptions, namespaces, and a standardized version of the STL with `std::vector`, `std::map`, `std::string`, iterators, and algorithms. If you've ever looked at older C++ code that uses `std::auto_ptr` or includes headers with `.h` suffixes, you're looking at C++98 in the wild.\n\nA small follow-up came in **2003**, called **C++03**. It was a \"technical corrigendum\", basically a bug-fix release for the standard. No new features. C++03 cleaned up wording issues, fixed defects in the spec, and clarified ambiguous behavior. From a programmer's perspective, C++98 and C++03 are usually treated as the same thing.\n\n---\n\n# The Stagnation Years (2003-2011)\n\nAfter C++03, the language went quiet. For roughly eight years, no new standard shipped. The committee was working on the next version, originally called \"C++0x\" (the `x` was supposed to be a single digit), but the scope kept growing and the deadline kept slipping. Some inside jokes called it \"C++1x\" once the calendar passed 2009.\n\nMeanwhile, the world moved on. **Java** dominated enterprise software. **Python** and **Ruby** got popular for scripting and web work. **C#** took over the Windows world. New languages came with garbage collection, simpler syntax, and faster iteration. C++ started to feel like the language you used when you had to, not the one you reached for first.\n\nThe common perception in this period was that C++ was a legacy language. It was still essential for games, browsers, operating systems, and high-performance backends, but a lot of developers stopped paying attention to it. A surprisingly stubborn version of this view still shows up in online debates, even though it's wildly out of date.\n\nWhat rescued C++ was the standard that finally shipped in 2011.\n\n---\n\n# The Modern C++ Revolution: C++11\n\nIn **September 2011**, the ISO committee published **C++11**, originally known as C++0x. It was the biggest update to the language since C++98, and people had been waiting for it for over a decade. Stroustrup himself described C++11 as feeling \"like a new language\", and that line still gets quoted in talks today.\n\nHere's the short version of what C++11 added:\n\n- **`auto`** keyword for type deduction, so you don't have to spell out long iterator types.\n- **Range-based for loops** (`for (auto& item : cart)`) for clean iteration.\n- **Lambda expressions** for inline, anonymous functions.\n- **Smart pointers** (`std::unique_ptr`, `std::shared_ptr`, `std::weak_ptr`) to manage memory without raw `new` and `delete`.\n- **Move semantics** and **rvalue references** (`&&`) to avoid unnecessary copies of large objects.\n- **`nullptr`** as a typed replacement for the old `NULL` macro.\n- **Uniform initialization** with `{}` braces.\n- **`override`** and **`final`** keywords for safer inheritance.\n- **`std::thread`**, **mutexes**, **futures**, and **atomics** for built-in concurrency.\n- **Variadic templates** for templates that take any number of arguments.\n\nAny one of these would have been a notable release. Together, they reshaped how everyday C++ code looks. Code written before C++11 is heavy on raw pointers, manual loops with verbose iterator types, and `NULL`. Code written after looks dramatically lighter.\n\nThe other big shift C++11 brought was cultural. The community started talking about **\"Modern C++\"** as a distinct style, one that leans on the standard library, prefers smart pointers over raw `new`, and uses move semantics to write fast code without low-level tricks. The phrase \"no naked `new`\" became a common piece of advice. Style guides like the **C++ Core Guidelines**, edited by Stroustrup and Herb Sutter, codified this approach.\n\n---\n\n# C++14 to C++23: The Three-Year Cadence\n\nAfter C++11 shipped, the committee decided not to repeat the eight-year wait. They committed to a **three-year release cadence**: a new standard every three years, even if it was a smaller one. That rhythm has held since 2011.\n\nHere's the timeline as a Mermaid diagram, with the milestones that matter most:\n\n\n```mermaid\nflowchart LR\n Y1979[1979
C with Classes]:::cyan --> Y1983[1983
Renamed C++]:::cyan\n Y1983 --> Y1998[1998
C++98 ISO]:::orange\n Y1998 --> Y2003[2003
C++03 Fix-up]:::teal\n Y2003 --> Y2011[2011
C++11 Revolution]:::green\n Y2011 --> Y2014[2014
C++14]:::cyan\n Y2014 --> Y2017[2017
C++17]:::cyan\n Y2017 --> Y2020[2020
C++20]:::green\n Y2020 --> Y2023[2023
C++23]:::orange\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n```\n\n\nThe diagram tracks the language from its prototype days through every ISO release. C++98 was the first standardized version, C++11 was the big reinvention, and everything after has come in three-year intervals.\n\n**C++14** (December 2014) was a small, polish-focused release. It added generic lambdas (`auto` parameters in lambda expressions), `std::make_unique`, return type deduction for regular functions, and binary literals like `0b1010`. Nothing earth-shaking, but enough quality-of-life improvements that most teams who'd jumped to C++11 happily upgraded.\n\n**C++17** (December 2017) brought more substantial features. **Structured bindings** let you unpack a `std::pair` or `std::tuple` into named variables in a single line. **`if constexpr`** allowed compile-time branching inside templates. **`std::optional`**, **`std::variant`**, and **`std::any`** filled long-standing gaps in the standard library. The **``** library standardized file and directory operations, replacing decades of platform-specific code. And **`std::string_view`** gave you a cheap, non-owning view into a string.\n\n**C++20** (December 2020) was the next big leap, almost on the scale of C++11. The headline features:\n\n- **Concepts**, which let you write constraints on template parameters in plain language instead of relying on cryptic SFINAE tricks.\n- **Ranges**, a new way to compose operations on sequences (`filter`, `transform`, `take`) without explicit iterators.\n- **Modules**, a long-awaited replacement for the C-style `#include` system that should eventually make C++ builds dramatically faster.\n- **Coroutines**, language-level support for functions that can pause and resume, useful for async I/O and generators.\n- The **three-way comparison operator** (`<=>`, called the \"spaceship operator\") to auto-generate all six comparison operators from one definition.\n\nC++20 also added smaller but high-impact features: `consteval` and `constinit`, designated initializers, calendar and time-zone support in ``, and `std::span` for non-owning views into contiguous data.\n\n**C++23** (published in 2024 after final approval in late 2023) is the most recent standard. It's smaller than C++20 but still useful: **`std::expected`** for error handling without exceptions, **`std::print`** and **`std::println`** for cleaner output than `std::cout`, **`std::flat_map`** and **`std::flat_set`** as cache-friendly alternatives to the tree-based containers, multidimensional subscript operator (`matrix[i, j]`), and a lot of ranges improvements like `views::zip` and `views::enumerate`.\n\nHere's the same information as a table you can use as a cheat sheet. These are the entries interviewers love to ask about:\n\n\n| Standard | Year | Signature Features |\n| -------- | ---- | ------------------ |\n| C++98 | 1998 | First ISO standard, STL, exceptions, templates, namespaces |\n| C++03 | 2003 | Bug-fix release, no new features |\n| C++11 | 2011 | `auto`, lambdas, smart pointers, move semantics, range-for, threads |\n| C++14 | 2014 | Generic lambdas, `make_unique`, binary literals |\n| C++17 | 2017 | Structured bindings, `if constexpr`, `optional`, `variant`, `filesystem` |\n| C++20 | 2020 | Concepts, ranges, modules, coroutines, spaceship operator |\n| C++23 | 2023 | `std::expected`, `std::print`, flat containers, multidim subscript |\n\n\nIf you only memorize a handful of dates, the rows above are the ones to keep in your head.\n\n---\n\n# Why the History Matters\n\nYou might wonder why any of this is worth memorizing. The answer is practical, not academic.\n\n**Code from every era still lives in production.** A real C++ codebase often mixes styles. The core might be C++98 because it was written in 2005 and nobody wants to touch it. A new module might be C++20 because the team is using a current compiler. You'll see `auto_ptr` (removed in C++17) sitting next to `std::unique_ptr` (added in C++11) in the same file. Knowing which features came when helps you read that code without getting confused.\n\n**Compiler flags matter.** Compilers default to a specific C++ standard, and that default has changed over time. GCC 11 defaults to C++17. GCC 13 defaults to C++17 by default but supports up to C++23 with the right flag. When you see `-std=c++17` or `-std=c++20` in a build script, you now know what it controls and which features are available.\n\n**Job interviews ask about it.** \"What's the difference between C++98 and modern C++?\" is a common opening question for senior C++ roles. So is \"what version added `nullptr`?\" or \"when were lambdas introduced?\". The answers are in the table above.\n\n**Library compatibility depends on it.** A library that requires C++20 won't compile on a project frozen at C++14. Knowing which features came in which standard tells you whether a dependency is realistic to adopt.\n\nStroustrup has said that one of his goals was for C++ to evolve without breaking old code. He's largely succeeded. A program written for C++98 will, with rare exceptions, still compile and run on a C++23 compiler. That backward compatibility is why so many systems written in the 1990s are still being maintained in modern C++ rather than rewritten from scratch.\n\n---\n\n# Summary\n\n- C++ was created by **Bjarne Stroustrup** at **Bell Labs** in **1979**, originally as **\"C with Classes\"**, a preprocessor that added Simula-style object-oriented features on top of C.\n- The language was renamed **C++** in **1983**, with the first commercial release in **1985** alongside Stroustrup's book *The C++ Programming Language*.\n- The first ISO standard, **C++98**, shipped in **1998** and locked in classes, templates, exceptions, namespaces, and the STL. **C++03** in 2003 was a fix-up release with no new features.\n- Between **2003 and 2011**, the language stagnated and started to feel legacy. The next standard, originally called C++0x, slipped repeatedly during this period.\n- **C++11** (2011) was a turning point, adding `auto`, lambdas, smart pointers, move semantics, range-based for loops, `nullptr`, and threading. Stroustrup called it \"feels like a new language\", and the term **Modern C++** dates from this release.\n- Since C++11, the committee has shipped a new standard every **three years**: **C++14** (polish), **C++17** (structured bindings, `std::optional`, ``), **C++20** (concepts, ranges, modules, coroutines), and **C++23** (`std::expected`, `std::print`, flat containers).\n- C++ has stayed remarkably backward-compatible, so code from C++98 usually still compiles on a C++23 compiler. That's why so many old codebases are still in active C++ use today.\n\nIn the next lesson, we'll look at the features that make C++ stand out as a programming language.","pageType":"cpp"}

History of C++

Get Premium