C++ — Cradle to Mastery

Stroustrup's original goal was C's raw performance combined with real object-oriented abstraction — a bet that classes and zero-cost abstraction could coexist with C's closeness to the machine. That same tension between abstraction and control still shapes every design decision C++ makes today.

Unlike languages with one reference implementation, C++ has three real, independently maintained compilers in everyday use — GCC, Clang, and MSVC — each adopting new standard features at its own pace. Getting one installed and a first file compiled is this lesson's entire goal.

The <code>auto</code> keyword saves you from writing out a long type by hand, but it changes nothing about C++'s static typing: the compiler still determines and locks in a concrete type at compile time, it just infers it from the initializer instead of requiring you to spell it out.

C++11's range-based <code>for</code> loop lets you iterate a container's elements directly, without hand-managing an index or an iterator — eliminating an entire category of off-by-one bugs that plagued C-style loops for decades.

Function overloading (multiple functions sharing a name, distinguished by parameter types) and default arguments are both genuine C++ additions with no C equivalent — C requires a separately named function for each variant instead. Both features rely on the compiler resolving the right call at compile time.

A C++ reference is not a pointer wearing a different syntax: it is a genuine alias for an existing variable, it cannot be reseated to refer to something else after initialization, and by the language's own rules it cannot be null. These constraints are exactly what makes references safer to pass around than raw pointers.

Namespaces let two entirely unrelated libraries each define a class named <code>Vector</code> without any collision, as long as each lives inside its own namespace — the mechanism that makes large C++ codebases and third-party libraries safely composable.

Unlike Java, a C++ method must be explicitly marked <code>virtual</code> to participate in dynamic dispatch — forget the keyword and a call through a base-class pointer silently resolves to the base class's version instead of the derived override, with no compiler error at all.

Operator overloading lets a custom type respond to <code>+</code>, <code>==</code>, <code>&lt;&lt;</code> and the rest with your own code, resolved at compile time by argument types — the exact same mechanism the standard library itself uses to make <code>std::string</code> concatenation and stream output work.

C++ genuinely allows a class to inherit from two (or more) base classes at once, unlike languages that restrict inheritance to a single parent. The famous diamond problem — two paths to a shared ancestor producing ambiguous, duplicated state — is the real complication that follows, and virtual inheritance is C++'s specific answer to it.

<code>new</code> and <code>delete</code> replace C's <code>malloc</code>/<code>free</code> and also run constructors and destructors, but idiomatic modern C++ style says to barely ever call either one directly — that responsibility belongs to RAII types and smart pointers instead, which the next two lessons cover.

<code>std::unique_ptr</code> and <code>std::shared_ptr</code> wrap raw <code>new</code>/<code>delete</code> calls inside RAII, automatically freeing memory when the smart pointer itself goes out of scope. Modern C++ style barely calls <code>new</code> or <code>delete</code> directly anymore because of exactly these two types.

Move semantics, introduced in C++11, let you transfer — 'steal' — a large object's internal buffer instead of copying it, leaving the original in a valid-but-empty state while the operation itself costs nearly nothing. This is the single biggest performance idea C++11 added to the language.

This lesson is the synthesis for the stage: class definition, constructors and destructors, RAII as the unifying idea, smart pointers, the rule of five, and move semantics &mdash; combined into the actual discipline experienced C++ code follows for resource management. Read it once each piece is familiar on its own.

<code>std::vector</code> is the correct default container for nearly every job in C++, with contiguous storage and cache-friendly access; reaching for <code>list</code>, <code>map</code>, or anything else should be a deliberate choice justified by a specific access pattern, not a habit.

Unlike Python or JavaScript closures, a C++ lambda forces you to explicitly state how it captures each outer-scope variable — by copy or by reference — rather than capturing everything implicitly. This explicitness is exactly what prevents a whole category of dangling-reference bugs in captured lambdas.

A template argument that didn't satisfy what a template actually required used to produce hundreds of lines of near-unreadable compiler error, often pointing deep inside library internals rather than at the actual mistake. C++20 concepts finally let a template state its real requirements directly, turning that wall of text into a clear, specific error message.

The <code>&lt;algorithm&gt;</code> header's functions — <code>std::sort</code>, <code>std::find</code>, <code>std::transform</code> and dozens more — replace hand-written loops with calls that are tested, typically better-optimized than a hand-rolled version, and self-documenting about intent.

This lesson is the synthesis for the stage: function and class templates, template specialisation, how the STL containers from earlier in this stage are themselves built from templates, iterators as the uniform interface between containers and algorithms, and the algorithms themselves &mdash; the whole generic-programming picture in one place.

When a C++ exception propagates, stack unwinding automatically calls the destructor of every local object that goes out of scope along the way — which is exactly why RAII and exceptions work so well together: cleanup happens whether a function returns normally or throws.

<code>std::optional</code>, <code>std::variant</code>, and C++23's <code>std::expected</code> each replace a pattern that used to require raw pointers, unions, or exceptions for the exact same job — representing absence, one-of-several-types, or an expected failure, respectively, with real type safety.

C++ inherits every one of C's undefined-behaviour categories wholesale, then adds genuinely new ones on top — an invalidated iterator used after a container reallocates, or a virtual function called from inside a constructor before the derived class even exists, are two real, C++-specific traps worth knowing by name.

C++20 added the <code>co_await</code> and <code>co_yield</code> keywords for suspending and resuming a function's execution, but shipped the language feature almost entirely without the concrete coroutine types needed to actually use it — those largely arrived later from third-party libraries, a genuinely unusual way for a major language feature to ship.

Destroying a <code>std::thread</code> object while its thread is still running, without first calling <code>join()</code> or <code>detach()</code>, calls <code>std::terminate</code> and kills the entire program — a sharp-edged default that <code>std::jthread</code>, added in C++20, finally fixes by joining automatically in its own destructor.

C++ inherited C's text-substitution preprocessor wholesale, but templates and <code>constexpr</code> now cover most of the jobs macros used to be the only tool for — type-safe generic code and compile-time computation, without a macro's total lack of type checking or scoping.

CMake is not a compiler or even a build tool in the direct sense: it generates the actual build files — a Makefile, a Ninja file, a Visual Studio project — for whatever tool your platform and toolchain actually prefer, which is exactly why the same CMakeLists.txt works across GCC, Clang, and MSVC alike.

C++ ships no standard test runner at all, unlike languages with one built into the toolchain. Google Test and Catch2 are the two frameworks nearly every real C++ codebase reaches for instead, each with genuinely different assertion styles and setup conventions worth knowing both of.

C++11 added so much at once — auto, lambdas, move semantics, the range-based for loop, smart pointers — that it is routinely called a second birth for the language, with C++14/17/20/23 each building incrementally on that one foundational release rather than any single one matching its scope.

This lesson is the course's synthesis and capstone: <code>auto</code>, lambdas, move semantics, <code>constexpr</code>, structured bindings, <code>std::optional</code>, concepts, ranges, and coroutines &mdash; the individual modern-C++ features from across this entire course, seen together as the toolkit that actually defines what 'writing modern C++' means in 2026.