C++ Roadmap

Advanced C++ programming topics.

29 stages · 114 topics 0% done
C++
✓ Template Basics & Instantiation
✓ Template Specialization
✓ Foundations
✓ Variadic Templates & Parameter Packs
✓ Alias Templates & Template Template Parameters
✓ Core Concepts
✓ Template Argument Deduction & Guides
✓ CRTP (Curiously Recurring Template Pattern)
✓ Compile-Time Computation (constexpr templates)
✓ Type Traits & SFINAE
✓ Intermediate Skills
✓ SFINAE Fundamentals
✓ std::enable_if & Overload Resolution
✓ Advanced Topics
✓ Expression SFINAE & decltype
✓ C++20 Concepts
✓ Requires Expressions
✓ Abbreviated Function Templates
✓ Expert Level
✓ Constrained Auto & Template Template Constraints
✓ Value Categories (lvalue, xvalue, prvalue)
✓ Mastery
✓ Move Constructor & Move Assignment
✓ std::move & std::forward
✓ Return Value Optimization (RVO/NRVO)
✓ Reference Collapsing Rules
✓ Ecosystem
✓ Move-Only Types & unique_ptr
✓ Perfect Forwarding in Variadic Templates
✓ Architecture
✓ RAII Principle
✓ std::unique_ptr Implementation
✓ std::shared_ptr & Control Blocks
✓ std::weak_ptr & Circular References
✓ Optimization
✓ Custom Deleters
✓ make_shared vs make_unique Performance
✓ Deployment
✓ enable_shared_from_this
✓ Allocator Model
✓ std::vector Growth & Reallocation
✓ std::map vs std::unordered_map Internals
✓ Phase 11
✓ std::string SSO (Small String Optimization)
✓ Iterator Categories & Invalidation
✓ Phase 12
✓ Parallel STL Algorithms (C++17)
✓ std::deque Block Structure
✓ Virtual Function Table (vtable)
✓ Virtual Inheritance & Diamond Problem
✓ Phase 13
✓ Dynamic_cast & RTTI
✓ CRTP Static Polymorphism
✓ Phase 14
✓ Policy-Based Design
✓ std::variant & std::visit Pattern
✓ Type Erasure (std::function, std::any)
✓ std::thread & jthread (C++20)
✓ Phase 15
✓ Mutex, Lock Guard & Unique Lock
✓ Condition Variables
✓ Phase 16
✓ std::atomic & Memory Ordering
✓ std::future & std::promise
✓ Thread Pools with std::async
✓ Lock-Free Programming with C++ Atomics
✓ Phase 17
✓ Coroutine Concepts (promise_type, awaitable)
✓ co_await & Awaitable Types
✓ Phase 18
✓ co_yield & Generator Patterns
✓ co_return & Promise Finalization
✓ Return Value Types (task, generator)
✓ Coroutine Frames & Allocation
✓ Phase 19
✓ Real-World: async I/O with Coroutines
✓ constexpr Functions (C++11/14/17/20)
✓ Phase 20
✓ consteval & constinit (C++20)
✓ Compile-Time Strings
✓ constexpr Containers
✓ Compile-Time Hashing
✓ Phase 21
✓ if constexpr for Compile-Time Branching
✓ Static Reflection with constexpr
✓ Phase 22
✓ Stack Unwinding & Exception Handling
✓ RAII & Exception Guarantees
✓ noexcept Specification & Optimization
✓ Exception Categories & Standard Exceptions
✓ Phase 23
✓ Exception-Safe Resource Management
✓ Copy-and-Swap Idiom
✓ Phase 24
✓ std::expected for Error Handling (C++23)
✓ As-If Rule & Undefined Behavior
✓ Copy Elision (C++17 Guaranteed)
✓ Return Value Optimization
✓ Phase 25
✓ Inline Expansion Heuristics
✓ Devirtualization
✓ Phase 26
✓ Loop Optimization & Vectorization
✓ Profile-Guided Optimization (PGO)
✓ Module Declarations & Interfaces
✓ Module Partitions
✓ Phase 27
✓ Header Units vs Modules
✓ Module Ownership & Reachability
✓ Phase 28
✓ Import & Export Semantics
✓ Private Module Fragments
✓ Migrating from Headers to Modules
✓ Phase 29
Text version of this roadmap

1. Foundations

  • Template Basics & Instantiation
  • Template Specialization
  • Variadic Templates & Parameter Packs

2. Core Concepts

  • Alias Templates & Template Template Parameters
  • Template Argument Deduction & Guides
  • CRTP (Curiously Recurring Template Pattern)

3. Intermediate Skills

  • Compile-Time Computation (constexpr templates)
  • Type Traits & SFINAE
  • SFINAE Fundamentals

4. Advanced Topics

  • std::enable_if & Overload Resolution
  • Expression SFINAE & decltype
  • C++20 Concepts

5. Expert Level

  • Requires Expressions
  • Abbreviated Function Templates
  • Constrained Auto & Template Template Constraints

6. Mastery

  • Value Categories (lvalue, xvalue, prvalue)
  • Move Constructor & Move Assignment
  • std::move & std::forward

7. Ecosystem

  • Return Value Optimization (RVO/NRVO)
  • Reference Collapsing Rules
  • Move-Only Types & unique_ptr

8. Architecture

  • Perfect Forwarding in Variadic Templates
  • RAII Principle
  • std::unique_ptr Implementation: The std::unique_ptr implementation pattern in Cpp provides a structured approach to handling RAII & Smart Pointers. Understanding the implementation details helps write more robust and maintainable code.

9. Optimization

  • std::shared_ptr & Control Blocks
  • std::weak_ptr & Circular References
  • Custom Deleters

10. Deployment

  • make_shared vs make_unique Performance: Performance considerations for make_shared vs make_unique performance in Cpp significantly impact application behavior. Understanding optimization strategies helps avoid common pitfalls and improve runtime characteristics.
  • enable_shared_from_this
  • Allocator Model

11. Phase 11

  • std::vector Growth & Reallocation
  • std::map vs std::unordered_map Internals: The internal architecture of std::map vs std::unordered_map internals in Cpp reveals how the runtime handles STL Internals. This knowledge enables more informed design decisions and debugging.
  • std::string SSO (Small String Optimization)

12. Phase 12

  • Iterator Categories & Invalidation
  • Parallel STL Algorithms (C++17)
  • std::deque Block Structure

13. Phase 13

  • Virtual Function Table (vtable)
  • Virtual Inheritance & Diamond Problem
  • Dynamic_cast & RTTI

14. Phase 14

  • CRTP Static Polymorphism
  • Policy-Based Design
  • std::variant & std::visit Pattern

15. Phase 15

  • Type Erasure (std::function, std::any)
  • std::thread & jthread (C++20)
  • Mutex, Lock Guard & Unique Lock

16. Phase 16

  • Condition Variables
  • std::atomic & Memory Ordering
  • std::future & std::promise

17. Phase 17

  • Thread Pools with std::async
  • Lock-Free Programming with C++ Atomics
  • Coroutine Concepts (promise_type, awaitable)

18. Phase 18

  • co_await & Awaitable Types
  • co_yield & Generator Patterns: Various coroutines (c++20) patterns emerge when working with co_yield & generator patterns in Cpp. These patterns provide reusable solutions to common programming challenges.
  • co_return & Promise Finalization

19. Phase 19

  • Return Value Types (task, generator)
  • Coroutine Frames & Allocation
  • Real-World: async I/O with Coroutines

20. Phase 20

  • constexpr Functions (C++11/14/17/20)
  • consteval & constinit (C++20)
  • Compile-Time Strings

21. Phase 21

  • constexpr Containers
  • Compile-Time Hashing
  • if constexpr for Compile-Time Branching

22. Phase 22

  • Static Reflection with constexpr
  • Stack Unwinding & Exception Handling
  • RAII & Exception Guarantees

23. Phase 23

  • noexcept Specification & Optimization
  • Exception Categories & Standard Exceptions
  • Exception-Safe Resource Management

24. Phase 24

  • Copy-and-Swap Idiom
  • std::expected for Error Handling (C++23)
  • As-If Rule & Undefined Behavior

25. Phase 25

  • Copy Elision (C++17 Guaranteed)
  • Return Value Optimization
  • Inline Expansion Heuristics

26. Phase 26

  • Devirtualization
  • Loop Optimization & Vectorization
  • Profile-Guided Optimization (PGO)

27. Phase 27

  • Module Declarations & Interfaces
  • Module Partitions
  • Header Units vs Modules

28. Phase 28

  • Module Ownership & Reachability
  • Import & Export Semantics
  • Private Module Fragments

29. Phase 29

  • Migrating from Headers to Modules