Complete C++ Developer Roadmap (Modern C++ 23)

Stage 0 — Setup (1 week)

• A recent compiler (gcc 13+, clang 17+, MSVC 19.38+).
• VS Code with C/C++ extension, CLion, or Visual Studio.
• CMake as the build system.
• vcpkg or Conan for dependencies.

Stage 1 — C++ Core (4 weeks)

• Hello world, compilation pipeline.
• Primitives + references + pointers.
• Control flow, loops, functions.
• Pass by value / reference / const reference.
• I/O — std::cout, std::cin, std::format.
• Strings + std::string.
• Containers — std::vector (and only later other STL containers).
• Algorithms — std::sort, std::find.

Project: CLI todo app using std::vector + JSON via nlohmann/json.

Stage 2 — OOP in C++ (3 weeks)

• Classes, constructors, destructors.
• Encapsulation — public / protected / private.
• Inheritance, virtual functions, polymorphism.
• Abstract classes, pure virtual functions.
• Operator overloading.
• friend functions / classes.

Stage 3 — Memory + RAII (2 weeks)

• Stack vs heap.
• new / delete — and why you don't use them in modern C++.
• Smart pointers — unique_ptr, shared_ptr, weak_ptr, make_unique, make_shared.
• RAII — bind resources to object lifetime.
• Rule of zero / three / five.
• Move semantics — std::move, rvalue references, perfect forwarding.

Stage 4 — STL Mastery (3 weeks)

• Containers — vector, array, deque, list, forward_list, set/multiset, map/multimap, unordered_set, unordered_map.
• Iterators + iterator categories.
• Algorithms — sort, find, transform, accumulate, partition, copy, count.
• Function objects + lambdas.
• Streams — <iostream>, <sstream>, <fstream>.

Stage 5 — Templates + Generic Programming (3 weeks)

• Function templates, class templates.
• Template specialisation.
• Variadic templates, parameter packs.
• SFINAE, std::enable_if.
• Concepts (C++20) — readable template constraints.
• CRTP, expression templates (mind-stretchers).

Stage 6 — Modern C++ (17 / 20 / 23) (2 weeks)

• C++17: structured bindings, std::optional, std::variant, std::any, if constexpr, fold expressions.
• C++20: concepts, modules, ranges, coroutines, std::format, std::span.
• C++23: std::print, deducing this, std::expected, multidim subscript.

Stage 7 — Concurrency (3 weeks)

• std::thread + std::jthread.
• std::async + std::future + std::promise.
• Mutexes — std::mutex, std::shared_mutex, std::scoped_lock.
• std::atomic, memory ordering.
• Condition variables.
• Parallel STL algorithms (std::execution::par).
• Coroutines basics.

Stage 8 — Tooling + Debugging (1 week)

• CMake — non-trivial projects.
• vcpkg / Conan for deps.
• gdb + lldb.
• AddressSanitizer, UBSan, TSan.
• clang-tidy + clang-format.
• Compiler Explorer (godbolt.org) — see what code your compiler emits.

Stage 9 — Testing (1 week)

• GoogleTest — most popular framework.
• Catch2 — header-only alternative.
• doctest — fastest compile times.
• Property-based testing.

Stage 10 — Specialise (ongoing)

Pick one:

• Game engines / graphics — Unreal, custom engines, Vulkan, OpenGL, DirectX.
• High-frequency trading / finance — extreme low latency, custom allocators.
• Embedded firmware — bare metal, real-time OS.
• Robotics — ROS2.
• Scientific computing — Eigen, GPU compute (CUDA/HIP).
• Compilers / language tools — LLVM, custom DSLs.

Capstone Projects

• A simple ray tracer (renders a scene to PNG).
• A multi-threaded download manager.
• A small DSL with parser + JIT (LLVM).

Time investment

Full-time: 6-9 months to job-ready.
Part-time (10 hr/week): 14-18 months.

C++ is huge. You don't need to know all of it. Focus on the modern, simple, RAII-driven subset.