Outline updated November 2026

Advanced35 hours delivered over 5 daysLive, online or on-site

Request this course

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

Private team training

Bring this course to your team

Tell us about your team and we will tailor this outline to your tools, stack, and schedule. Courses can also be combined into a longer program.

  1. Tell us what you needYour tools, stack, team size, and timeline.
  2. We send a proposalA course or program, an outline adjusted to your team, and possible dates.
  3. Your team trains liveOnline or on-site, with courseware for every student.

Prefer to talk? Call +1 434-509-6890 or email help@cloudcontraptions.com.

We reply within 1 business day.

Training partner?