c3-6 named this course directly: the next step once OOP is layered on top of everything the C track already covers. Most of what you already know still applies. This chapter is about the specific places it doesn't.

g++ and clang++

The same underlying toolchains as c1-1's gcc/clang, extended for C++. The situation around build tooling hasn't changed either — no official package manager or build system, exactly as before; make/CMake still fill that gap, and c2-5's own Makefile material transfers directly, unchanged.

What's Source-Compatible With C

A large majority of valid C code compiles as valid C++, unchanged: variables, control flow, functions, arrays, pointers, and plain structs all carry over. Everything the C track covered about manual memory, bounds checking, and pointer discipline still applies at the same level as before — none of that gets replaced, only added to.

What's Not Compatible

A concrete, common example: in C, malloc's void * return implicitly converts to any pointer type. In C++, it does not — an explicit cast is required.

This reflects a broader theme worth noting immediately: C++'s type checking is stricter than C's in several places, not looser.

iostream vs. stdio

cout/cin/cerr are C++'s own I/O streams — using << and >>, which are genuinely overloaded operators (Chapter 6 covers writing your own), not format-string parsing the way printf/scanf work. Both remain fully usable in C++ — <cstdio> still works — but iostream is the idiomatic choice.

The Compile-Then-Link Model, Unchanged

c1-1's compile-then-link model transfers completely unchanged — same two conceptual steps, same idea of object files and linking. The only visible difference is convention: C++ source files typically use a .cpp extension, and g++ replaces gcc.

The Smallest C++ Program

Compare directly against c1-1's own hello world — the shape is identical; only the I/O mechanism changed.

Coding Challenges

c1-3 spent real time on C's historical lack of a true boolean. This chapter opens by closing that gap for good — then introduces something the C track never had at all.

A Genuine bool From Day One

C had no boolean type until C99, and even then, bool is a macro over _Bool — genuinely just an integer in disguise. C++ has had a real, distinct bool primitive since its very first standard. true and false are genuine keyword literals of their own type — not macros standing in for 1 and 0.

References — A New Concept Beyond Pointers

A reference is an alias for an existing variable — not a separate object with its own address the way a pointer is.

Two real, permanent constraints: a reference must be initialized the moment it's declared — there's no such thing as an uninitialized or null reference the way there's an uninitialized or null pointer — and once bound, it can never be rebound to refer to something else.

References vs. Pointers

cpp1-8 covers exactly when to reach for each in real code — this is just the first introduction.

auto Type Inference

auto lets the compiler deduce a variable's type from its initializer. C has no equivalent at all — every variable's type is always written explicitly. This is genuinely a point where C++ and Rust agree (Rust's let does the same thing), unlike most of the C track's own C-vs-Rust contrasts.

const in C++

Used far more pervasively and idiomatically in C++ than in C. A const variable's value cannot change after initialization — a full dedicated chapter on const-correctness comes later (cpp2-8); for now, just the basic qualifier.

Coding Challenges

c1-5's functions had one name each, always. This chapter introduces the first genuinely new C++ capability that has no C equivalent at all — not a missing feature, a structural impossibility in C's own linking model.

Function Overloading

Multiple functions can share the same name, distinguished by their parameter types or count — the compiler picks the right one based on the actual arguments at each call site.

C cannot do this at all. C compiles every function name directly to one plain, unmangled linker symbol — two functions named print in the same C program is simply a redefinition error, per c2-5's own linking material.

Name Mangling, Briefly

C++ solves this by encoding parameter types into the actual linker symbol name. print(int) and print(double) become genuinely different symbols under the hood — something like _Z5printi and _Z5printd.

This directly extends c2-5's own linker material: overloading isn't possible because the linker got smarter — it's possible because C++ generates different names for what looks, in source, like the same function name.

extern "C"

A real, practical need: calling a C library from C++, or being called from C code, requires plain, unmangled names. extern "C" tells the compiler to use C's own naming rules for specific declarations — this is exactly why standard C headers are internally wrapped in extern "C" when included from C++.

Default Arguments

A genuinely new feature: parameters can have default values, letting a function be called with fewer arguments than it declares.

C has no equivalent at all — the closest workaround is a variadic function, or several separately-named functions.

Overload Resolution Ambiguity

If a call could plausibly match more than one overload after implicit conversions, the compiler reports an ambiguous call error rather than guessing.

Coding Challenges

c2-1 named this chapter's whole subject directly: "one way C approximates method-like dispatch without a language feature for it at all." This chapter is that language feature.

From struct to class

c2-1's C struct was pure data — no methods, ever; any function operating on it had to be written separately, taking a pointer as its first argument. A C++ class bundles data and methods together directly, inside the same definition, called with object.method() syntax instead of function(&object).

A First Class

Compare directly against c2-7's own hand-rolled Circle struct with a manually-wired function pointer. Same idea — the language now does the wiring for you.

public and private Access Control

A genuinely new concept: members can be hidden from outside code entirely. A class's members are private by default; a struct's are public by default — the only real difference between the two keywords in C++, worth naming explicitly since it's a common point of confusion.

This is enforced by the compiler — unlike C, where a struct's members are always fully exposed, with zero protection of any kind.

Constructors

A special member function that runs automatically when an object is created — replacing the "manually call an init function" pattern C never even had a formal concept for. Multiple constructors are possible, reusing cpp1-3's own overloading rules directly.

Destructors

A special member function that runs automatically when an object is destroyed — a genuine preview of RAII, this course's own central chapter, coming next.

this — A Hidden Parameter

Inside a member function, this is a pointer to the object the method was called on — exactly the explicit self/void * parameter c2-7 required passing by hand in plain C. The compiler now supplies it invisibly, every call.

Coding Challenges

c2-2 was the C track's own central chapter: manual malloc/free, with every allocation carrying real risk of a forgotten free. This chapter is C++'s answer — and, genuinely, it's the same answer Rust would later give.

RAII — Resource Acquisition Is Initialization

The core idea: tie a resource's lifetime directly to an object's lifetime. Acquire the resource in the constructor; release it in the destructor. When the object goes out of scope — through any exit path, including an early return or an exception — the destructor runs automatically, releasing the resource with zero remaining programmer effort at that point.

A Worked RAII Example — A Simple Owning Wrapper

Compare this directly against c2-2's own discipline: "every allocation needs a matching free, and the programmer must remember every single time." Here, allocate once in the constructor, and never have to remember to free again — the destructor handles it unconditionally, even during an exception unwind.

The Direct Rust Parallel

This is, genuinely, exactly Rust's Drop trait — invented roughly fifteen years earlier, via manual class-writing instead of a language-level trait system. Rust's own ownership model (rust1-3) and smart pointers (rust2-2) were historically compared to, and influenced by, this exact C++ idiom. A real, rare moment of genuine convergent evolution between the two languages, unlike most of the C track's own contrasts.

new and delete

C++'s own heap-allocation operators — a real, concrete improvement over C's malloc/free. new allocates and calls the constructor automatically; delete calls the destructor and frees the memory. Raw malloc/free know nothing about object lifecycles at all — just bytes.

Mismatching them — new with delete[], or vice versa — is undefined behavior, the exact same category c3-4 covered in full.

The Rule of Three, Previewed

A class managing a resource manually generally needs a destructor, a copy constructor, and a copy assignment operator together — or copies of the object risk a double-free exactly like c2-3's own bug catalog. Full depth arrives in cpp2-8; this is just the forward pointer.

Exception Safety, Briefly

RAII's other major payoff, previewed ahead of cpp2-6's own Exception Handling chapter: because destructors run on any scope exit — including an exception unwinding through the call stack — RAII-managed resources are cleaned up automatically even when an error is thrown mid-function. C's manual cleanup pattern has no equivalent mechanism at all; C has no exceptions and no automatic stack unwinding.

Coding Challenges

Every std::cout << ... line since cpp1-1 has quietly relied on a mechanism this chapter finally names directly.

Why Operator Overloading

A Vector2D class: adding two vectors should read naturally as v1 + v2, not add(v1, v2). C has no equivalent mechanism at all — every "operation" on a struct must be a plainly-named function call, always.

Overloading +

Written as a member function, this supplies the left operand implicitly; other is the right one.

Overloading ==

Returns a genuine bool — cpp1-2's own real boolean primitive, put to direct use.

Overloading << for Output

A real exception to the pattern so far: operator<< must be a free function, not a member — the left operand is std::ostream&, not the class itself, so it can't be written as a member of Vector2D. A friend declaration lets the free function reach the class's private members.

Which Operators Can/Can't Be Overloaded

Most can — arithmetic, comparison, stream, subscript [], function-call (), and more. A small, fixed set genuinely cannot: ::, ., .*, ?:, sizeof — a real exclusion list, not an arbitrary restriction.

The Real Payoff — This Is What cout << Already Uses

Here's the reveal: std::cout << 5 is itself a call to operator<<(ostream&, int) — an overload of exactly this same operator, just for a built-in type instead of a custom one. Every cout statement since Chapter 1 has been using this mechanism the entire time.

Coding Challenges

c2-7 ended by naming this chapter directly: what a struct of function pointers, wired up by hand, actually becomes once C++ does it for you. This is that reveal, in full.

Base and Derived Classes

Without virtual — The Problem

A genuine, surprising gotcha: calling area() through a Shape * pointing at a Circle calls Shape's own area(), not Circle's. This is static binding — resolved at compile time, based on the pointer's declared type, not the actual object it points to.

virtual — Making Dispatch Real

Adding virtual changes everything: dispatch now resolves at runtime, based on the actual object's real type. This is exactly c2-7's own hand-built mechanism, made real by the language.

The vtable, Named Directly

Under the hood, a class with virtual functions gets a hidden vtable — a table of function pointers, exactly c2-7's own hand-rolled Circle struct with its own function-pointer member. Every object of such a class carries a hidden pointer to its class's vtable. Calling a virtual function through a base pointer looks up the real function through this table, at runtime — literally the same shape->area(shape) code c2-7 wrote by hand, now generated automatically.

override and Pure Virtual Functions

override (C++11+) is a safety check confirming a derived function genuinely overrides a base virtual — catching typos or signature mismatches as compile errors instead of silently creating an unrelated function.

= 0 marks a pure virtual function — the class becomes abstract, unable to be instantiated directly, requiring every derived class to provide its own implementation.

Coding Challenges

cpp1-2 introduced references structurally. This chapter is the practical guidance — when to reach for each — and the honest comparison against what Rust's own references actually guarantee.

Recap: The Structural Differences

When to Use a Reference

Primarily function parameters: passing a large object by reference avoids an expensive copy while still letting the function read or modify the caller's actual object. Return types too — but never return a reference to a local variable; that's the exact reference-shaped version of c1-7's own dangling-pointer warning.

const Reference — Pass-By-Reference Without Copying, Safely

const T& is the real, idiomatic C++ default for passing anything nontrivial into a function — it avoids the copy plain pass-by-value would make, while const guarantees the function can't accidentally modify the caller's object. Genuinely the most common parameter-passing pattern in real C++ code.

When to Use a Pointer

• "No object" (null) is a genuinely valid state to represent
• The thing being pointed to needs to be reassigned to point elsewhere later
• Pointer arithmetic — iterating a raw array, exactly c1-6/c1-7's own territory
• Ownership semantics via smart pointers — previewed for Course 2

Contrasted With Rust's Borrow Rules

Rust's &/&mut references are checked at compile time by the borrow checker for aliasing rules — you cannot have a mutable reference and any other reference to the same data alive simultaneously. C++ references have none of these guarantees enforced at all: a const T& and a plain T& to the same object can coexist freely, and nothing stops two non-const references from both mutating the same data unsafely — including from two different threads, tying directly to cpp3-4's own concurrency chapter. This is a real, genuine gap this course's own framing has been building toward: C++ references solve C's raw-pointer ergonomics problem — no dereference syntax, no null, no rebinding — but not its safety problem.

Coding Challenges

Every single example since cpp1-1 has written std::cout, never just cout. This closing chapter finally explains why — and previews everything Course 2 is about to build on top of it.

The Global Namespace Problem

C has exactly one flat namespace for every function and variable name across an entire program. Two libraries both defining a function called process genuinely collide — a real, historical C problem with no built-in solution.

std:: — The Standard Library's Own Namespace

This is why every example so far has written std::cout: C++'s entire standard library lives inside a namespace called std, specifically so it never collides with anything the programmer names themselves.

Declaring Your Own Namespace

using namespace — Convenient But Risky

using namespace std; brings every std:: name into scope unqualified — genuinely convenient for small examples, but it reintroduces exactly the collision risk namespaces exist to prevent.

A Standard Library Tour, Previewing Course 2

A quick map of what's coming, not the full depth yet:

• std::string — a real, growable string type, unlike C's own raw char arrays
• std::vector — the direct answer to c3-2's own "C has no standard containers" gap
• std::map — a built-in key-value structure, replacing c3-2's own hand-rolled hash table

Course 2's own dedicated chapters cover each in full — this is just naming what's ahead.

Closing Course 1

From cpp1-1's compile model through cpp1-8's honest safety-gap admission, one throughline: C++ adds real capability on top of C — overloading, classes, RAII, polymorphism, safer references — without adding Rust's own compile-time safety guarantees. That tension is exactly what Course 3's concurrency and UB chapters make fully concrete. Course 2, starting next, is about the practical, everyday tools — templates, the STL, smart pointers, move semantics — built directly on this foundation.

Coding Challenges