Outline updated November 2026
Effective Modern C++
Class Duration
35 hours of live training delivered over 5 days.
Student Prerequisites
- Professional C++ programming experience
- Working knowledge of classes, pointers, and the standard library basics
- Familiarity with Git
Target Audience
Working C++ developers whose habits predate the modern standards, or who use modern features without full command of them. It fits teams maintaining large C++ codebases that they want to make safer and modernize. Developers new to C++ should start with C++ and Object-Oriented Programming.
Description
This course covers the idioms of modern C++, up through the newest standard. Students work through move semantics, ownership design, type deduction, lambdas, concepts, ranges, and compile-time programming with static reflection. They then apply these to concurrency and safety: coroutines, std::execution, SIMD types, contracts, erroneous behavior, and the hardened standard library. The course ends with incremental modernization of legacy code. Students use AI coding assistants for mechanical refactoring and test generation, and learn to review that output critically.
Learning Outcomes
- Explain value categories, move semantics, and copy elision.
- Design ownership with smart pointers, and know where raw pointers are correct.
- Apply auto, decltype, structured bindings, and CTAD correctly.
- Write callables with lambdas, captures, and function_ref.
- Constrain templates with concepts and replace SFINAE-era code.
- Compose data transformations with ranges, views, and projections.
- Move computation to compile time with constexpr, consteval, and reflection.
- Write concurrent code with threads, atomics, coroutines, and std::execution.
- Use parallel algorithms and std::simd.
- Apply contracts, hardened library modes, and sanitizers, and know what each guarantees.
- Modernize legacy code incrementally with modules and clang-tidy.
- Review AI-generated modernization refactors with expert judgment.
Training Materials
Comprehensive courseware is distributed online at the start of class.
Software Requirements
Visual Studio 2026 (Windows) or VS Code with a current GCC or Clang toolchain (any platform), plus CMake and Git. Portions of the course covering C++26-specific features use GCC or Clang where MSVC support lags. WG21 finished technical work on C++26 in March 2026, but the October 2026 ISO ballot on the draft did not pass, so publication is pending and C++26 features may still change. Coverage of individual C++26 features follows the standard's status and compiler support at delivery time. Access to an agentic AI coding assistant is required; a free tier is sufficient.
Training Topics
Modern C++ Today
- How the modern standards evolved
- How a standard ships
- Working drafts and ISO ballots
- When features reach your compiler
- GCC, Clang, and MSVC support
- The C++ Core Guidelines
- Memory safety and C++'s response
- AI assistants in modernization work
Value Semantics and Move Machinery
- lvalues, rvalues, and xvalues
- Move construction and move assignment
- Forwarding references
- Perfect forwarding
- Copy elision and RVO
- Common move pessimizations
Ownership and Resource Design
- unique_ptr as the default
- shared_ptr costs and control blocks
- The shared_ptr aliasing constructor
- weak_ptr and reference cycles
- The rule of zero
- Handles, views, and non-owning types
Type Deduction Mastery
- auto deduction rules
- decltype and decltype(auto)
- Structured bindings
- Class template argument deduction
- When explicit types read better
Lambdas and Callables
- Value, reference, and init captures
- Generic and templated lambdas
- std::function vs. function_ref
- Stateful callables
Templates and Concepts
- Concepts and requires clauses
- Designing good concepts
- Migrating SFINAE and enable_if code
- Variadic templates and fold expressions
- Explicit instantiation and build times
Ranges and Algorithms
- Views and lazy composition
- Projections and range adaptors
- Range-friendly interfaces
- Ranges vs. classic algorithms
Compile-Time Programming
- constexpr and consteval
- Compile-time data structures
- Static reflection with ^^ and std::meta
- Splicing
- Serialization and bindings with reflection
Concurrency and Parallelism
- jthread and cooperative cancellation
- Atomics and the memory model
- Coroutine generators and tasks
- Senders, receivers, and schedulers
- Sender algorithms
- std::execution::task and counting_scope
- The parallel scheduler
- Parallel algorithms and execution policies
- Data-parallel types with std::simd
Error Handling, Contracts, and Safety
- Exception safety in modern code
- std::optional and std::expected
- Error-code design
- Contracts with pre, post, and contract_assert
- Evaluation semantics and violation handlers
- Erroneous behavior for uninitialized reads
- Opting out with [[indeterminate]]
- The hardened standard library
- Hardening in libc++, libstdc++, and the Microsoft STL
- Sanitizers and UB hygiene
- Memory-safe coding guidelines
Modernizing Legacy Code
- Incremental migration strategies
- Adopting modules in existing code
- clang-tidy modernize checks
- AI-assisted refactoring campaigns
- Measuring performance and defect changes