Advanced techniques: Explore widely used modern C++ features with hands-on practice.
Dive into templates, lambdas, smart pointers, multithreading, and metaprogramming with concise examples.
Understand the runtime costs and best practices of modern features in production code.
Gain practical experience with extensive labs and real-world scenarios (~70% hands-on).
How this course helps: apply modern C++ effectively in professional projects.
Who it’s for: designed for developers with prior C++ knowledge at beginner-to-intermediate level.
By the end, you’ll be confident using advanced modern C++ across domains.
Curriculum
Elements of modern C++
- User-defined literals
- Improved string literals for non-trivial applications
- Ranges & Views (C++20)
- Coroutines (C++20)
- Modules (C++20)
- constexpr improvements (e.g., heap allocations, virtual calls)
- Designated initializers (C++20)
- Three-way comparison operator (<=>) (C++20)
- Pattern matching (C++23 preview/ C++26)
- Reflection & metaprogramming (C++26 preview)
Modern templates and metaprogramming
- Variadic templates
- Fold expressions (C++17)
- Template variables
- Concepts & Constraints (C++20)
- Class Template Argument Deduction (CTAD) (C++17)
- Non-type template parameters (C++20/23)
- Using auto in templates (C++14/17/20)
- constexpr metaprogramming
- Type traits enhancements (e.g., std::is_scoped_enum, std::remove_cvref)
Practical functional programming
- Lambdas
- Parameters and return types
- Capture expressions
- Mutable lambdas
- Generic lambdas
- How lambdas work
- Initialized lambda captures
- std::function and std::invoke
- Higher-order functions
Multithreading and parallelism
- Basics: visibility, atomicity
- Atomic operations in modern C++
- std::atomic_ref (C++20)
- std::jthread (scoped threads with auto-join)
- Mutexes and locks
- Condition variables: usage and real-world scenarios
- Common gotchas in concurrent code
- Asynchronous execution
- futures / promises
- packaged_task
- std::async and policies
- std::stop_token (C++20)
- Parallel STL algorithms (C++17/20): e.g., transform_reduce, sort with execution policies
Smart pointers
- unique_ptr
- shared_ptr
- weak_ptr
- Advanced pitfalls and best practices
Miscellaneous modern C++
- rvalues and lvalues
- lvalue vs. rvalue references
- Perfect forwarding
- Move constructors and move assignment
- Type deduction refinements (decltype(auto), scoped enums)
- Enhanced constexpr capabilities
- std::span (C++20)
- Deprecating older features (std::bind, raw pointers in new code, old-style casts)
- std::optional, std::variant, and std::any
Under the hood
- Runtime cost of C++ features
- Virtual and pure virtual functions
- Object layout and addresses under (multiple) inheritance
- Performance cost of coroutines, concepts, modules
- Memory model evolution (std::atomic, std::pmr allocators)
- Inlining (automatic vs. link-time): pros and cons
- STL views & laziness
Optional modules
A concise CMake introduction (if time allows)
- Build a small project with CMake
- Start a new project or migrate an existing one from scratch
Course Day Structure
- Part 1: 09:00–10:30
- Break: 10:30–10:45
- Part 2: 10:45–12:15
- Lunch: 12:15–13:15
- Part 3: 13:15–15:15
- Break: 15:15–15:30
- Part 4: 15:30–17:30