Free through lesson 3

C++ for Beginners

From building with clang++ and iostream to classes and RAII, the STL, templates, smart pointers, ranges and threads, and finally CMake and unit tests. Over 50 lessons, you'll get to the point where you "let types manage resource lifetimes, and can build and ship one small tool." Every code sample, compile error, and sanitizer report was actually run with clang++ 21 (C++23).

Start from lesson 1 Unlock every course

Curriculum

The 50 lessons are split into 7 chapters. We recommend going in order from chapter 1, but feel free to jump to whatever interests you. Note: C++ can't run in the browser, so compile and try the samples locally with clang++ 16 or later, or g++ 13 or later (with C++23 support). The course assumes you know C (pointers and malloc).

Chapter 1 — From C to C++ (lessons 1–7)

You'll rewrite code you could write in C using C++ tools, learning iostream, references, namespaces, auto, range-based for, and overloading along the way. By the end of this chapter, you'll be able to read and write C code as C++.

1

Your First Steps in C++ (Building with clang++)

Just the differences a C programmer hits first: building with clang++, Hello World with iostream, how it differs from printf, and the one spot where C code stops compiling as C++.

Free
2

std::string and I/O

Freedom from managing char arrays and '\0'. Concatenation, comparison, substrings, reading a line, and measuring why you shouldn't write std::endl on every line.

Free
3

References (&): Modifying Without Writing Pointers

Rewrite C's "modify the caller" functions, full of & and *, with references. Check addresses to see a reference is a non-rebindable alias and that const references avoid copies.

Free
4

Namespaces and using

Create a clash between functions with the same name, then wrap them in a namespace. Why to avoid using namespace std, namespace aliases, and anonymous namespaces as a replacement for C's static.

🔒 Basic
5

auto and Range-Based for

auto lets you skip writing type names, and range-based for replaces index loops. Forgetting auto & makes a copy, and auto can pick up a type you didn't intend.

🔒 Basic
6

Function Overloading and Default Arguments

Provide a same-named function for each type. The order in which one is chosen, cases that stop as ambiguous, and accidents when combined with default arguments.

🔒 Basic
7

nullptr, enum class, and Structured Bindings

Replace risky habits inherited from C with C++ alternatives. NULL vs nullptr, typed enumerations, and structured bindings for receiving two return values.

🔒 Basic

Chapter 2 — Classes and RAII (lessons 8–14)

You'll bundle data and behavior into classes, and let constructors and destructors tie resource lifetimes to types. Then you'll cover copying, moving, and operator overloading, ending with types you wrote yourself that work naturally with = and +.

8

Classes and Member Functions

Put functions inside a C struct. Use public and private to control access, and const member functions to state "read only" in the type.

🔒 Basic
9

Constructors and Initializer Lists

Put an object in a known state the moment it's created. Assigning in the body vs initializer lists, initialization order, delegating constructors, and const members.

🔒 Basic
10

Destructors and RAII

Destructors run the instant an object leaves scope. Wrap fopen and fclose in a type so that returning early never leaves a file open.

🔒 Basic
11

Copy Constructors and the Rule of Three

The default copy is a shallow, member-by-member copy. Trigger a real double free with a class holding a raw pointer, then provide copy constructor, copy assignment, and destructor as a set.

🔒 Basic
12

Move Semantics

Move the contents instead of copying. Rvalue references (&&) and std::move, move constructors and move assignment, and the Rule of Five.

🔒 Basic
13

explicit and Implicit Conversions

Accidents from single-argument constructors called behind your back. Stop them with explicit, stop narrowing with {} initialization, and use explicit operator bool only in if.

🔒 Basic
14

Operator Overloading

Make your own types work with +, ==, and <<. When to use a member vs a free function, and how <=> collapses comparisons into one line.

🔒 Basic

Chapter 3 — STL (lessons 15–22)

You'll learn vector, map, and set, plus the iterators and algorithms that cut across all of them. Loops you used to write by hand become a single line from <algorithm>, and lambdas let you pass "how to compare" right on the spot.

15

std::vector Basics

Replace the "growable array" you built with malloc and realloc. Adding, accessing, and removing, what happens when you go out of range, and making a 2D vector.

🔒 Basic
16

How vector Grows (capacity and reserve)

Measure the difference between size and capacity. How many reallocations happen, how much faster reserve makes things, and a sanitizer catching references invalidated by reallocation.

🔒 Basic
17

std::map and std::unordered_map

Containers you look up by key. Ordered map vs fast unordered_map, the trap where [] silently creates elements, and when to use contains vs find.

🔒 Basic
18

std::set and Removing Duplicates

A container that drops duplicates and keeps things sorted just by inserting. Use insert's return value to tell if something was new, define your own ordering, and choose vs unordered_set.

🔒 Basic
19

Iterators

A common tool for walking through any container. Half-open ranges with begin and end, the link to pointers, what each kind can do, and invalidation.

🔒 Basic
20

The <algorithm> Essentials

Turn hand-written loops into one line. Sorting, searching, counting, summing, the erase-remove idiom, and binary search.

🔒 Basic
21

Lambda Expressions

Small functions written on the spot. Syntax, capture by value vs by reference, mutable, return types, lifetime traps, and std::function.

🔒 Basic
22

Combining Algorithms and Lambdas

Using sales data, chain sorting, filtering, transforming, and aggregating. back_inserter and transform, binary operations for accumulate, and stable sorting.

🔒 Basic

Chapter 4 — Templates (lessons 23–29)

Stop copying the same logic for every type and fold it into one template. You'll cover specialization, parameter packs, constexpr, and concepts, and get to the point where you can read template errors on your own.

23

Function Templates

Stop copying the same function for each type. Type deduction, explicit arguments, two or more type parameters, and why errors don't appear until instantiation.

🔒 Basic
24

Class Templates

Build your own "type whose element type you choose," like std::vector. Writing member functions, non-type parameters, and deducing types from arguments (CTAD).

🔒 Basic
25

Template Specialization

Swap in different contents for one specific type. Full and partial specialization, why to prefer overloading for functions, and the order in which specializations are chosen.

🔒 Basic
26

Variadic Templates

Accept any number of arguments. Parameter packs and sizeof..., fold expressions that collapse it into one line, and perfect forwarding to pass things along as-is.

🔒 Basic
27

constexpr and consteval

Do calculations at compile time. constexpr functions and static_assert, consteval for guaranteed constants, and if constexpr for branching on types.

🔒 Basic
28

Concepts

State in a template "which types it works with." Standard concepts, writing your own with requires, and comparing how much shorter the error messages get.

🔒 Basic
29

Type Deduction Pitfalls and Reading Template Errors

auto drops const and references, decltype and decltype(auto), dependent types need typename, and tips for reading long errors from the top.

🔒 Basic

Chapter 5 — Memory and Ownership (lessons 30–36)

First you'll actually break things with new and delete, then replace them with unique_ptr and shared_ptr. You'll learn to write code that doesn't leak resources even when exceptions fly, and finish by checking the Rule of Five with a string class you write yourself.

30

new and delete, and the Trouble with Raw Pointers

Turning malloc and free into new and delete solves nothing. Forgetting [], forgetting to free, and the root problem: "who frees this?" can't be expressed in the type.

🔒 Basic
31

unique_ptr

Write "exactly one owner" into the type. make_unique, move-only (no copying), use in function parameters and return values, and custom cleanup.

🔒 Basic
32

shared_ptr and weak_ptr

Reference counting for multiple owners. How use_count changes, leaks from cyclic references, breaking the cycle with weak_ptr, and why to use make_shared.

🔒 Basic
33

Exceptions (throw, try, catch)

Throw errors you can't report through return values. The std::exception family, why to catch by const reference, custom exceptions, and destructors running during unwinding.

🔒 Basic
34

Exception Safety and RAII

Code that doesn't break when exceptions fly. Plug leaks from new with unique_ptr, tell the basic guarantee from the strong one, and tidy up with copy-and-swap.

🔒 Basic
35

Building Data Structures with Smart Pointers

Write a binary search tree with unique_ptr. Children are owned; the parent is only borrowed. Search, insert, traversal, and the recursion depth problem in destructors.

🔒 Basic
36

[Project] Build a Small String Class

Write the Rule of Five all by hand. Count allocations, copies, moves, and frees to verify behavior, then see why you'd still use std::string.

🔒 Basic

Chapter 6 — Modern C++ (lessons 37–44)

This chapter covers optional, variant, string_view, span, and ranges, plus threads and synchronization. You'll express "a value that might be missing" and "exactly one of several types" with types, and run multiple tasks at the same time.

37

std::optional

Express "there might be no value" with a type. Drop conventions like null pointers or -1; use has_value and value_or, and learn the rules for getting the value out.

🔒 Basic
38

std::variant and std::visit

Safely hold "exactly one of several types." How it differs from union, index and get, branching with visit, and monostate.

🔒 Basic
39

string_view and span

Pass a "look but don't copy" view. Slice substrings with string_view, accept arrays and vectors the same way with span, and watch out for lifetimes.

🔒 Basic
40

ranges Basics

No more writing both begin and end. std::ranges algorithms, projections, and a first look at the idea of views.

🔒 Basic
41

Combining ranges Views

Chain take, drop, split, join, enumerate, and zip to write aggregation as a single pipeline. Infinite ranges, and when you must not return a view.

🔒 Basic
42

std::thread

Run work at the same time. Creating a thread and join, passing arguments, hardware_concurrency, and measuring how touching the same variable breaks things.

🔒 Basic
43

mutex and Mutual Exclusion

Stop data races. lock_guard and scoped_lock, when atomic is enough, how deadlocks happen and how to avoid them, and the strongest move of all: don't share.

🔒 Basic
44

std::async and future

Get results without touching threads directly. async launch policies, future's get, how exceptions propagate, and passing values yourself with promise.

🔒 Basic

Chapter 7 — Building It for Real (lessons 45–50)

You'll put together header splitting, CMake, unit tests, and sanitizers to finish one small tool. Finally, we'll line up the differences from C and Rust and hand you a map of where to go next.

45

Splitting Code into Multiple Files

Declarations in headers, definitions in .cpp files. #pragma once, how to read undefined reference, and why templates are the exception.

🔒 Basic
46

Building with CMake

Stop typing compiler commands by hand. A minimal CMakeLists.txt, libraries and executables, and confirming that only what changed gets rebuilt.

🔒 Basic
47

Writing Unit Tests

Build your own 20-line macro test tool with no external libraries. Register it with CMake's ctest, and break things on purpose to confirm the tests fail.

🔒 Basic
48

[Project] Build a Word Frequency Counter

Read a file, split it into words, count them, and print the most frequent first. Combine command-line arguments, ifstream, map, and ranges::sort into one tool.

🔒 Basic
49

Debugging and Sanitizers

Find bugs before they crash instead of hunting after. The address, undefined, and thread sanitizers, assert, and bugs that vanish under optimization.

🔒 Basic
50

Wrap-Up: How C++ Differs from C and Rust, and What to Learn Next

Line up the same task in C, C++, and Rust to compare how each handles ownership and errors. Areas this course didn't cover, and where to go next.

🔒 Basic

Once you've finished all 50 lessons, move on to Rust for Beginners, where the compiler watches ownership for you; the C Intro Course, the foundation C++ is built on; or Intro to Shipping and Running a Service, to ship what you build. A membership unlocks every course.