Skip to main content

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.

74 lessons0 challenges~15 hoursBeginner — no experience needed

Prerequisite course:C++ — Intermediate

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.

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.