C++ Advanced
Reason about what the machine, the compiler, and other threads are actually doing: lifetime mechanics, generic library design, compile-time computation, lazy pipelines, hand-built coroutines — onward to the memory model, concurrency, allocators, performance, and production practice.
Who this course is for
Engineers who finished C++ Intermediate (STL, RAII, move-semantics basics, introductory templates) and now want systems-level reasoning: the memory model, concurrency, performance engineering, and library architecture.
What you will be able to do
- Predict object lifetime, value category, and initialization outcomes exactly, and debug code that violates them
- Implement perfect forwarding, resource wrappers, and exception-safe moves; explain RVO and copy elision mechanically
- Write generic libraries with specialization, variadic folds, if constexpr, NTTPs, and CTAD
- Design concept-constrained APIs and read constraint-failure diagnostics efficiently
- Move computation to compile time with constexpr/consteval/constinit and type traits
- Build and debug range pipelines, write custom iterator-backed views, and avoid view-dangling bugs
- Implement a coroutine generator from promise_type primitives and reason about coroutine lifetimes
- Explain the C++ memory model and choose memory orderings with justification
- Build thread pools, task runtimes, and concurrent queues with appropriate synchronization
- Engineer memory layouts: arenas, pools, std::pmr, and data-oriented design
- Optimize with evidence: measure, hypothesize, change, re-measure — with benchmark rigor
- Diagnose and repair undefined behavior by class: dangling, overflow, aliasing, races
- Debug like an operator: symbols, stack traces, minimization, logging and tracing design
- Test like a sceptic: property-based, fuzz-style, deterministic concurrency, performance-regression tests
- Build and link professionally: modern CMake targets, presets, visibility, LTO, CI matrices
- Design for binary compatibility: ODR, ABI, symbol visibility, plugin boundaries
- Write network services with framing, timeouts, and backpressure; audit and harden them
- Architect at scale and operate services: boundaries, observability, graceful shutdown
- Audit and harden systems code: injection-proof parsers, integer-overflow-safe arithmetic, hardened builds
- Ship an integrated service core against an acceptance battery, deterministically verified
The Advanced Object Model
Value categories, storage duration, and initialization — the machinery every other advanced topic is defined in terms of. You will predict exact behavior before running anything.
Move Semantics Under the Hood
Forwarding references, reference collapsing, std::forward, guaranteed elision, and the noexcept that makes vector growth move — the mechanics beneath the syntax you already use.
Advanced Templates
Specialization, variadics, fold expressions, if constexpr, NTTPs, and CTAD — the techniques behind every serious generic library, each aimed at a real problem.
- Specialization: Full, Partial, and Variable Templates⭐⭐⭐ advanced⏳ 12 min read
- Variadic Templates and Fold Expressions⭐⭐⭐ advanced⏳ 11 min read
- if constexpr, NTTPs, and Compile-Time Data⭐⭐⭐ advanced⏳ 11 min read
- CTAD and Deduction Guides⭐⭐⭐ advanced⏳ 10 min read
- Checkpoint: Generic Machinery⭐ beginner⏳ 16 min read
Concepts & Constrained APIs
requirements, ad-hoc constraints, subsumption, and diagnostics — design APIs whose misuse is a clear compiler error instead of a runtime surprise.
Compile-Time C++
constexpr, consteval, constinit, and type traits — move work from runtime to build time and let the compiler refuse invalid configurations.
Ranges & Lazy Pipelines
Views, adaptors, projections, and custom pipelines — transform data lazily, compose cleanly, and know exactly where view lifetimes bite.
Coroutines from First Principles
co_await, co_yield, promise_type, and the handles that drive them — build a generator with your own hands so async C++ never looks like magic again.
The C++ Memory Model
Data races, happens-before, atomics, and memory orderings — the formal backdrop that turns threading from folklore into engineering.
Advanced Concurrency
Threads, jthread, mutexes, condition variables, futures, and the design of a thread pool — build the plumbing every server owns.
Memory Architecture & Allocators
Where allocations really cost, how pmr arenas reshape ownership, and why data layout beats micro-optimization.
Performance Engineering
Measure first, optimize with evidence: allocation counts, stride costs, and algorithmic wins verified by deterministic graders.
Undefined Behavior & Defensive C++
The UB zoo, boundaries that make bad input impossible, and the sanitizer mindset that turns heisenbugs into test failures.
Advanced Debugging & Diagnostics
Debugger discipline, reading crash forensics, and shrinking giant failures into one-file repros — the incident-response toolkit.
Advanced Testing & Verification
Test pyramids for C++, property-based thinking, and mutation/fuzz testing that measure whether your tests can actually fail.
Advanced Build Systems
CMake targets and properties, Debug/Release flag engineering, presets, and the configuration values your code can see at compile time.
ABI, Linking & Compatibility
API vs ABI, name mangling, ODR, visibility — and the pimpl/extern-C/function-table patterns that let a shipped library evolve without breaking its binaries.
Networking & Systems
TCP is a byte stream: framing, robust parsing, timeouts, and backpressure — the protocol layer every high-performance service is built on.
Secure Systems Programming
The memory-safety and input-validation bug classes behind real CVEs — and the hardened implementations that close them, with regression tests as the deliverable.
Architecture & Production
Dependency inversion with real seams, event-driven decoupling, and configuration precedence — the structure that keeps large C++ systems changeable.
Capstone — High-Performance Service
Integrate the whole course in one deterministic service core: admission windows with provenance, an exact audit trail, and a ship gate that accepts nothing less.