C++

The name C++ comes from C's increment operator ++. Just as i++ means "increment i by one," C++ is a play on words meaning "C taken one step forward."

The original name was "C with Classes," reflecting Stroustrup's goal of porting Simula's class system into C. In 1983, a colleague named Rick Mascitti suggested the name C++, and it stuck. Stroustrup later wrote, half-jokingly, that ++C (prefix increment, which returns the updated value) might have been more accurate — a remark that C veterans tend to smile at.

In the late 1970s, Stroustrup was using Simula 67 for distributed-systems research at Bell Labs while working alongside the Unix team. Simula 67 had pioneered object-oriented programming — classes, inheritance, and virtual functions — and was well-suited to modeling complex systems. Its weakness was speed: Simula programs were too slow for production system software.

C, on the other hand, was fast enough to write Unix kernels and gave direct access to hardware. Stroustrup wanted a language that combined Simula's abstraction power with C's execution speed. In 1979, he began developing "C with Classes," and the system was in internal use at Bell Labs by 1980.

The early version offered classes, basic inheritance, inline functions, default arguments, and stronger type checking. It worked by running source code through a preprocessor called Cpre, which translated it into C before compilation.

Stroustrup articulated C++'s design principles clearly, and the central idea is zero-cost abstraction: you should not pay for what you do not use, and what you do use should be at least as efficient as handwritten code.

This philosophy stands in contrast to Java's approach of "prevent mistakes through restrictions." C++ aims to be a language in which a skilled programmer can write anything from bare-metal code to high-level abstractions, trusting that the programmer knows what they are doing.

C++ draws from C and Simula 67, and went on to influence a wide range of later languages.

1979: C with Classes development begins

Stroustrup begins porting Simula-style class features into C at Bell Labs. The initial implementation uses a preprocessor called Cpre to translate the new syntax into standard C before compilation.

1985: C++ 1.0 released commercially

The language is renamed from "C with Classes" to "C++." The first commercial version includes classes, virtual functions, operator overloading, references, and constants. The same year, Stroustrup publishes The C++ Programming Language (TC++PL), which plays a major role in spreading adoption.

1998: C++98 — first ISO standard

C++ is standardized as ISO/IEC 14882. The Standard Template Library (STL), designed by Alexander Stepanov at Hewlett-Packard, is incorporated into the standard library, establishing containers, algorithms, and iterators as core abstractions. This makes generic programming a central paradigm in C++.

2003: C++03 — technical corrections

A revision that fixes technical errors and ambiguities in C++98. No new language features are added; the focus is on specification consistency.

2011: C++11 — the birth of Modern C++

The largest revision in 13 years. C++11 introduces move semantics, lambda expressions, auto type inference, smart pointers (unique_ptr / shared_ptr), range-based for, nullptr, enum class, and the concurrency library (std::thread). The term "Modern C++" emerges, referring to code that uses these features. The gap between pre-2011 and post-2011 C++ is large enough that they can feel like different languages.

2014 / 2017: C++14 and C++17

C++14 refines C++11 usability (generic lambdas, std::make_unique, return type deduction). C++17 adds structured bindings, if constexpr, std::optional, std::filesystem, and parallel algorithms, significantly expanding the standard library.

2020: C++20 — four pillars

A revision comparable in scale to C++11. The four headline features are concepts (constraints on template parameters), ranges (range-based algorithm interface), coroutines (suspendable functions for async and generators), and modules (a replacement for #include that improves compile times). Concepts in particular make template error messages dramatically more readable.

2023: C++23

A refinement rather than a major revision. Notable additions include std::expected (a type representing either success or failure) and std::print (a modern formatted-output facility).

Game engines

Unreal Engine, parts of Unity, and the core of Godot are written in C++. Game development demands real-time performance at 60 frames per second and cannot afford GC pauses. C++'s RAII-based deterministic resource management makes it the dominant language for AAA game development.

Embedded systems

Microcontrollers and automotive systems require minimal memory footprint and real-time responsiveness. C++ can run on bare-metal hardware (without an OS), making it a practical choice alongside C in deeply embedded contexts.

High-performance computing and scientific work

Physics simulations, financial calculations, and the C++ backends of machine-learning frameworks such as TensorFlow and PyTorch all rely on C++. In domains where raw computation speed translates directly to value, C++ remains a primary choice.

Databases and infrastructure

MySQL, PostgreSQL, MongoDB, Apache Kafka, and the core of Google Chrome are implemented in C++. Infrastructure software that handles large volumes of data at high speed continues to reach for C++ when performance and control both matter.

"C++ is a strict superset of C"

This claim is widely repeated but is not precisely accurate. Early C++ was designed to be nearly compatible with C, but the two standards have diverged. Some valid C code does not compile as C++: implicit void * conversions, C-only keywords like restrict, and variable-length arrays (VLAs) are examples. The accurate picture is that C and C++ are sibling languages that share a common ancestor and a large common subset, but are not in a strict superset relationship.

"C++ is too hard — avoid it"

Much of C++'s reputation for difficulty comes from the accumulated complexity of decades of additions. Modern C++ (C++11 and later) on a practical subset — smart pointers, auto, range-based for, STL containers — lets a programmer accomplish most tasks without touching the more obscure corners of the language. As with C, it is not necessary to know every feature to be productive.

"Rust will replace C++"

Rust addresses memory safety at the compiler level and is seeing growing adoption for new systems-programming projects. However, decades of existing C++ codebases — game engines, embedded firmware, financial infrastructure — are not going to be rewritten in the short term. The two languages are expected to coexist for a long time.

• Class / Object — the basic unit of OOP in C++
• Templates — the mechanism for generic programming
• Smart Pointers — unique_ptr / shared_ptr / weak_ptr
• RAII — Resource Acquisition Is Initialization
• Move Semantics — avoiding copies with rvalue references (C++11)
• Lambda Expressions — anonymous functions added in C++11
• STL — Standard Template Library
• History of C — the language C++ grew from
• History of Java — a language that drew from C++