C++ Advanced Course

Lesson 1 • Uniform Initialisation and Structured Bindings

Explains brace initialisation, initialiser lists, and C++17 structured bindings. Reduces common initialisation bugs in subsequent chapters.

Lesson 2 • Move Semantics and Value Categories

Explains lvalues, rvalues, and xvalues alongside std::move and std::forward. Enables efficient resource transfer throughout the course.

Lesson 3 • Smart Pointers and Ownership

Covers unique_ptr, shared_ptr, and weak_ptr ownership semantics. Builds the memory-safety foundation required for advanced resource management.

Lesson 4 • Lambda Expressions in Depth

Teaches capture modes, generic lambdas, and mutable lambdas. Prepares students for functional-style algorithms and callbacks.

Lesson 1 • SFINAE and Enable_if Techniques

Explains substitution failure, std::enable_if, and void_t idioms. Allows conditional template enablement based on type properties.

Lesson 2 • Type Traits and Compile-Time Computation

Covers the type_traits library and constexpr if for compile-time branching. Students write zero-overhead generic code with static assertions.

Lesson 3 • Variadic Templates

Teaches parameter packs, pack expansion, and fold expressions. Unlocks construction of type-safe heterogeneous containers and utilities.

Lesson 4 • Function and Class Template Basics

Introduces template syntax, instantiation, and argument deduction rules. Provides the vocabulary for all subsequent metaprogramming topics.

Lesson 1 • Constraining Function and Class Templates

Applies concepts to function signatures and class templates via requires clauses. Replaces verbose SFINAE with expressive constraints.

Lesson 2 • Concept Syntax and Definition

Introduces the concept keyword, requires expressions, and constraint conjunction. Establishes the new vocabulary for constrained templates.

Lesson 3 • Standard Library Concepts

Surveys concepts in <concepts> and ranges headers including Sortable and Range. Enables idiomatic use of the C++20 standard library.

Lesson 1 • Memory Pools and Arena Allocation

Covers pool allocators, arena allocators, and bump-pointer strategies. Reduces fragmentation and allocation latency in hot paths.

Lesson 2 • Placement New and Object Lifetime

Teaches manual object construction in pre-allocated buffers using placement new. Clarifies object lifetime rules to avoid undefined behaviour.

Lesson 3 • Memory Safety and Sanitizer Tools

Introduces AddressSanitizer, Valgrind, and undefined-behaviour sanitizers. Students detect and fix memory errors systematically.

Lesson 4 • Aligned Storage and SIMD Alignment

Covers alignas, alignof, and std::aligned_storage for hardware-aligned data. Prepares students for SIMD and cache-line optimisation.

Lesson 1 • C++20 Coroutines for Concurrency

Introduces co_await, co_yield, and coroutine handles for async workflows. Connects coroutine mechanics to practical async I/O patterns.

Lesson 2 • Threads, Mutexes, and Condition Variables

Covers std::thread, mutex variants, and condition_variable for synchronisation. Builds practical skills for producer-consumer and guarded-data patterns.

Lesson 3 • C++ Memory Model Fundamentals

Explains the happens-before relation, sequentially consistent ordering, and data races. Provides the theoretical basis for all concurrency work.

Lesson 4 • Atomics and Lock-Free Programming

Teaches std::atomic operations and compare-exchange for lock-free structures. Students implement wait-free counters and lock-free queues.

Lesson 1 • Compiler Optimisations and Hints

Covers inlining, link-time optimisation, and likely/unlikely hints. Students guide the compiler to generate faster machine code.

Lesson 2 • Reducing Allocations and Copies

Covers small-buffer optimisation, copy elision, and RVO/NRVO guarantees. Students eliminate hidden allocation costs in production code.

Lesson 3 • Profiling and Benchmarking Workflow

Covers perf, gprof, and Google Benchmark for measuring hotspots. Establishes a data-driven optimisation methodology used throughout the chapter.

Lesson 4 • SIMD Intrinsics and Vectorisation

Introduces auto-vectorisation and manual SIMD intrinsics for data parallelism. Enables order-of-magnitude speedups on numeric workloads.

Lesson 1 • Policy-Based Design

Teaches the policy class idiom for compile-time behaviour injection. Replaces virtual dispatch with zero-cost static polymorphism.

Lesson 2 • Compile-Time Reflection Patterns

Covers manual reflection using type lists, constexpr maps, and X-macros. Prepares students for C++26 reflection when it becomes available.

Lesson 3 • Type Erasure Techniques

Explains std::any, std::function, and custom type-erasure wrappers. Enables runtime polymorphism without inheritance hierarchies.

Lesson 4 • Expression Templates

Introduces expression templates for lazy evaluation and loop fusion. Students build a minimal linear-algebra DSL to apply the pattern.

Lesson 1 • CMake and Build System Mastery

Teaches modern CMake targets, generator expressions, and package management. Enables reproducible, cross-platform builds for large projects.

Lesson 2 • ABI Stability and Versioning

Explains ABI breakage causes, the pimpl idiom, and versioned symbol techniques. Students design libraries that remain binary-compatible across releases.

Lesson 3 • Static Analysis and Code Quality

Covers clang-tidy, cppcheck, and sanitizer integration in CI pipelines. Enforces consistent quality gates across large teams.

Lesson 4 • C++20 Modules System

Covers module units, interface partitions, and import declarations. Replaces header-based compilation for faster builds and cleaner dependencies.