The Complete Modern C++ Course
A zero-to-advanced Modern C++ curriculum: learn the language with safe standard-library types, master classes and resource ownership, build generic and concurrent software, and finish with professional portfolio projects.
Phase 1 · Modern C++ Foundations
Compilation, values, types, streams, strings, decisions, loops, functions, and references.
Introduction to Programming & Modern C++
Discover what Modern C++ is, how source becomes a native program, set up a C++20 compiler, and build your first executable.
Variables, Fundamental Types & Operators
Represent and transform data with fundamental types, safe initialization, constants, inference, expressions, and conversions.
Console I/O, Strings & Formatting
Communicate through standard streams, work with std::string, format results, read complete lines, and recover from invalid input.
Decisions & Control Flow
Make programs choose safely with Boolean logic, if/else, switch, scoped enums, short-circuiting, and conditional expressions.
Loops & Iteration
Repeat work with while, do-while, classic for, and range-based for while reasoning about boundaries and termination.
Functions, Scope, References & Program Structure
Organize programs with functions, value and reference parameters, overloads, scope, storage duration, recursion, and clean interfaces.
Phase 2 · Classes, Ownership & Resource Safety
Containers, lifetimes, classes, RAII, value semantics, operators, and polymorphism.
Arrays, std::array, std::vector & std::span
Choose and use C++ sequence types, understand capacity and invalidation, and pass contiguous views safely.
Pointers, Lifetimes & Dynamic Memory
Understand addresses and lifetimes, distinguish ownership from observation, and replace fragile manual allocation with safer defaults.
Classes, Objects & Encapsulation
Model behavior and invariants with cohesive classes, controlled access, const-correct member functions, and clear definitions.
Constructors, Destructors & RAII
Establish valid objects and deterministic cleanup with constructors, destructors, member initialization, composition, and RAII.
Copying, Moving & the Rule of Zero
Design predictable value types using generated special members, copying, moving, and resource-owning members.
Operator Overloading & Conversions
Make domain types feel natural without surprises by overloading operators and controlling conversions deliberately.
Inheritance, Polymorphism & Interfaces
Use runtime polymorphism safely, prevent slicing, design abstract interfaces, and know when composition is the stronger choice.
Phase 3 · Generic Programming & the Standard Library
Templates, concepts, containers, algorithms, ranges, callables, errors, files, and serialization.
Templates & Concepts
Write reusable, type-safe generic code with function and class templates, deduction, parameter packs, and semantic constraints.
Standard Containers & Adaptors
Select standard sequence, associative, unordered, and adaptor containers from their contracts and complexity guarantees.
Iterators, Algorithms & Ranges
Express data processing with iterator ranges, standard algorithms, projections, and lazy C++20 range pipelines.
Lambdas, Callables & Functional Tools
Pass and compose behavior with lambdas, function objects, captures, std::function, and invocation utilities.
Exceptions, optional, variant & expected
Model failures and alternatives with exceptions, safety guarantees, optional values, closed variants, and expected-style results.
Streams, Filesystem & Serialization
Process files and directories, parse structured text, and design explicit versioned formats for persistent data.
Phase 4 · Advanced C++ & Systems Programming
Value categories, ownership graphs, compile-time programming, concurrency, coroutines, and low-level integration.
Value Categories, Move Semantics & Perfect Forwarding
Reason precisely about expression categories, reference collapsing, forwarding, elision, and lifetime-sensitive interfaces.
Smart Pointers, Ownership Graphs & Allocators
Represent complex ownership with smart pointers, avoid shared cycles, and control allocation through polymorphic memory resources.
Compile-Time Programming & Metaprogramming
Move appropriate computation and validation to compile time with constexpr, consteval, type traits, folds, and constrained metaprogramming.
Concurrency & the C++ Memory Model
Coordinate threads and asynchronous results while preventing races, deadlocks, and invalid memory-order assumptions.
Coroutines & Asynchronous Design
Understand C++ coroutine mechanics and build lifetime-aware generators and task abstractions for asynchronous workflows.
Binary Data, Interoperability & Low-Level C++
Work safely at platform boundaries with bytes, alignment, bit operations, C APIs, operating-system resources, and explicit wrappers.
Phase 5 · Professional C++ Engineering
Testing, diagnostics, CMake, architecture, APIs, performance, portability, and security.
Debugging, Testing & Undefined Behavior
Find and prevent defects through diagnostics, debugger evidence, automated tests, sanitizers, analysis, and defined-behavior discipline.
CMake, Dependencies, Libraries & Packaging
Build, consume, install, version, test, and package C++ targets reproducibly with modern CMake and continuous integration.
Architecture, Design Patterns & API Design
Create maintainable C++ systems with stable boundaries, deliberate polymorphism, dependency direction, patterns, and compatible APIs.
Performance, Portability & Secure C++
Profile real workloads, improve algorithms and data layout, harden trust boundaries, and ship portable optimized C++ without undefined behavior.
Phase 6 · Portfolio
Six graduated projects that turn the complete course into demonstrable engineering work.