Skip to main content

Learning path

C/C++ learning path: everything to study, topic by topic

Comprehensive C/C++ assessment covering C fundamentals, object-oriented programming, templates, STL containers and algorithms, memory management, smart pointers, move semantics, multithreading, metaprogramming, and modern C++ features (C++11 through C++23).

Short answer

To learn C/C++, work through 6 modules and 24 topics in the order they build on each other. It starts with C Fundamentals, then moves on to C++ Basics and Object-Oriented C++. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
24
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · C Fundamentals4 topics
  • Variables & Types

    Fundamental data types (int, float, double, char, bool), type modifiers (short, long, unsigned), type casting, sizeof, typedef, type aliases, const qualifier, volatile

    Objectives

    • Declare variables with appropriate types and modifiers
    • Understand type casting and promotion rules

    Key concepts

    • fundamental data types
    • type modifiers (short, long, unsigned)
    • implicit and explicit type casting
    • sizeof operator
    • typedef and using aliases
    • const qualifier
    • volatile keyword
    • type promotion rules
  • Control Flow

    if/else, switch/case, for loops, while/do-while, break/continue, ternary operator, goto, nested loops, short-circuit evaluation

    Objectives

    • Write correct conditional and loop constructs
    • Understand switch fall-through behavior

    Key concepts

    • if/else statements
    • switch/case with fall-through
    • for loop
    • while and do-while
    • break and continue
    • ternary operator
    • short-circuit evaluation
    • nested loops
  • Functions

    Function declarations and definitions, parameter passing (by value), return types, function prototypes, default arguments, inline functions, recursion, function overloading basics

    Objectives

    • Write functions with proper signatures and prototypes
    • Understand pass-by-value semantics and recursion

    Key concepts

    • function declaration vs definition
    • pass by value
    • return types
    • function prototypes
    • default arguments
    • inline functions
    • recursion
    • function overloading
  • Pointers & Arrays

    Pointer declaration and dereferencing, pointer arithmetic, arrays, C-style strings, multi-dimensional arrays, void pointers, null pointers, function pointers

    Objectives

    • Use pointers and pointer arithmetic correctly
    • Understand array-to-pointer decay

    Key concepts

    • pointer declaration and dereferencing
    • pointer arithmetic
    • arrays and decay to pointers
    • C-style strings (char*)
    • multi-dimensional arrays
    • void pointers
    • nullptr
    • function pointers
2 · C++ Basics4 topics
  • Strings & I/O

    std::string, string operations, C++ I/O streams (cin, cout, cerr), file I/O (ifstream, ofstream), string streams, getline, formatting with iomanip

    Objectives

    • Use std::string and I/O streams effectively
    • Read and write files with fstream

    Key concepts

    • std::string
    • string concatenation and comparison
    • cin/cout/cerr
    • ifstream/ofstream
    • stringstream
    • getline
    • iomanip formatting
    • string_view (C++17)
  • References

    Lvalue references, const references, pass by reference, reference vs pointer, dangling references, reference collapsing, returning references

    Objectives

    • Pass arguments by reference efficiently
    • Distinguish references from pointers

    Key concepts

    • lvalue reference (&)
    • const reference (const &)
    • pass by reference
    • reference vs pointer
    • dangling references
    • reference collapsing rules
    • returning references safely
    • reference to const extends lifetime
  • Namespaces

    Namespace declaration, using directives, using declarations, nested namespaces, anonymous namespaces, inline namespaces, namespace aliases, ADL (argument-dependent lookup)

    Objectives

    • Organize code with namespaces
    • Understand ADL and its implications

    Key concepts

    • namespace declaration
    • using directive
    • using declaration
    • nested namespaces (C++17)
    • anonymous namespaces
    • inline namespaces
    • namespace aliases
    • ADL (Koenig lookup)
  • Auto & Type Inference

    auto keyword, decltype, type deduction rules, trailing return types, structured bindings (C++17), auto with references and const, decltype(auto)

    Objectives

    • Apply auto and decltype for cleaner code
    • Use structured bindings for tuple/struct unpacking

    Key concepts

    • auto keyword
    • decltype
    • type deduction rules
    • trailing return types
    • structured bindings
    • auto with const and references
    • decltype(auto)
    • class template argument deduction (CTAD)
3 · Object-Oriented C++4 topics
  • Classes

    Class definition, access specifiers, constructors, destructors, member initializer lists, this pointer, static members, friend functions, aggregate initialization

    Objectives

    • Design classes with proper encapsulation
    • Apply the Rule of Three/Five/Zero

    Key concepts

    • class vs struct
    • public/private/protected
    • constructors and destructors
    • member initializer list
    • this pointer
    • static members
    • friend functions
    • Rule of Three/Five/Zero
  • Inheritance

    Single and multiple inheritance, access control in inheritance, virtual base classes, constructor/destructor order, slicing, diamond problem, protected members

    Objectives

    • Implement inheritance hierarchies correctly
    • Resolve the diamond problem with virtual base classes

    Key concepts

    • single inheritance
    • multiple inheritance
    • public/protected/private inheritance
    • virtual base classes
    • constructor/destructor call order
    • object slicing
    • diamond problem
    • using declarations in derived classes
  • Polymorphism

    Virtual functions, pure virtual functions, abstract classes, vtable mechanism, override and final specifiers, dynamic_cast, RTTI, virtual destructors

    Objectives

    • Implement runtime polymorphism with virtual functions
    • Understand the vtable mechanism

    Key concepts

    • virtual functions
    • pure virtual functions
    • abstract classes
    • vtable and vptr
    • override specifier
    • final specifier
    • dynamic_cast and RTTI
    • virtual destructors
  • Operator Overloading

    Overloading arithmetic, comparison, and stream operators, member vs non-member overloads, conversion operators, subscript and function-call operators, user-defined literals

    Objectives

    • Overload operators following C++ conventions
    • Choose between member and non-member overloads

    Key concepts

    • arithmetic operator overloading
    • comparison operators (spaceship <=> C++20)
    • stream operators (<<, >>)
    • member vs non-member overloads
    • conversion operators
    • subscript operator []
    • function-call operator ()
    • user-defined literals
4 · STL & Templates4 topics
  • Templates

    Function templates, class templates, template specialization, partial specialization, non-type template parameters, variadic templates, SFINAE, concepts (C++20)

    Objectives

    • Write generic code with function and class templates
    • Apply template specialization and SFINAE

    Key concepts

    • function templates
    • class templates
    • template specialization
    • partial specialization
    • non-type template parameters
    • variadic templates
    • SFINAE
    • concepts (C++20)
  • STL Containers

    Sequence containers (vector, deque, list, array, forward_list), associative containers (set, map, multiset, multimap), unordered containers (unordered_map, unordered_set), container adaptors (stack, queue, priority_queue)

    Objectives

    • Choose appropriate containers by use case and complexity
    • Understand iterator invalidation rules

    Key concepts

    • std::vector
    • std::map / std::unordered_map
    • std::set / std::unordered_set
    • std::deque / std::list
    • std::array
    • std::stack / std::queue
    • std::priority_queue
    • container complexity guarantees
  • Iterators & Algorithms

    Iterator categories (input, output, forward, bidirectional, random access), STL algorithms (sort, find, transform, accumulate, copy), ranges (C++20), views

    Objectives

    • Apply STL algorithms effectively
    • Use C++20 ranges for composable data processing

    Key concepts

    • iterator categories
    • begin/end and cbegin/cend
    • std::sort / std::find / std::transform
    • std::accumulate / std::reduce
    • std::copy / std::move
    • std::ranges (C++20)
    • range views and pipes
    • custom comparators
  • Lambda Expressions

    Lambda syntax, capture clauses (by value, by reference, init-capture), generic lambdas, mutable lambdas, std::function, std::bind, higher-order functions

    Objectives

    • Write lambdas with appropriate capture modes
    • Use lambdas with STL algorithms

    Key concepts

    • lambda syntax [captures](params){body}
    • capture by value [=]
    • capture by reference [&]
    • init-capture (C++14)
    • generic lambdas (auto parameters)
    • mutable lambdas
    • std::function
    • immediately invoked lambda
5 · Memory & Concurrency4 topics
  • Smart Pointers

    std::unique_ptr, std::shared_ptr, std::weak_ptr, custom deleters, make_unique/make_shared, ownership transfer, enable_shared_from_this, pointer aliasing

    Objectives

    • Choose the right smart pointer for each ownership model
    • Avoid common smart pointer pitfalls

    Key concepts

    • std::unique_ptr
    • std::shared_ptr
    • std::weak_ptr
    • std::make_unique / std::make_shared
    • custom deleters
    • ownership transfer (std::move)
    • enable_shared_from_this
    • aliasing constructor
  • Move Semantics

    Rvalue references, std::move, move constructors, move assignment, perfect forwarding, std::forward, copy elision, RVO/NRVO

    Objectives

    • Implement move constructors and move assignment operators
    • Apply perfect forwarding correctly

    Key concepts

    • rvalue references (&&)
    • std::move
    • move constructor
    • move assignment operator
    • perfect forwarding
    • std::forward
    • copy elision (RVO/NRVO)
    • universal references
  • Multithreading

    std::thread, std::mutex, std::lock_guard, std::unique_lock, condition variables, std::async, std::future, std::promise, atomic operations, thread safety

    Objectives

    • Write thread-safe code with mutexes and atomics
    • Use async/future for concurrent task execution

    Key concepts

    • std::thread
    • std::mutex / std::lock_guard
    • std::unique_lock
    • std::condition_variable
    • std::async / std::future
    • std::promise
    • std::atomic
    • data races and thread safety
  • Memory Management

    new/delete, placement new, memory alignment, allocators, memory leaks, stack vs heap, RAII pattern, custom allocators, memory pools

    Objectives

    • Apply RAII for deterministic resource management
    • Detect and prevent memory leaks

    Key concepts

    • new/delete operators
    • placement new
    • memory alignment (alignas, alignof)
    • custom allocators
    • RAII pattern
    • stack vs heap allocation
    • memory pools
    • memory leak detection
6 · Advanced C++4 topics
  • Modern C++ Features

    C++17 features (optional, variant, any, filesystem, if constexpr), C++20 features (concepts, modules, coroutines, three-way comparison), C++23 features (expected, deducing this, std::print)

    Objectives

    • Apply modern C++ vocabulary types (optional, variant)
    • Use concepts to constrain templates

    Key concepts

    • std::optional
    • std::variant / std::visit
    • std::any
    • std::filesystem
    • if constexpr
    • concepts and requires (C++20)
    • modules (C++20)
    • coroutines (C++20)
  • Template Metaprogramming

    Compile-time computation, type traits (std::is_integral, std::enable_if), constexpr if, consteval, SFINAE techniques, tag dispatch, CRTP, expression templates

    Objectives

    • Apply template metaprogramming for compile-time computation
    • Use CRTP and policy-based design patterns

    Key concepts

    • type traits (std::is_*, std::enable_if)
    • constexpr computation
    • consteval (C++20)
    • SFINAE techniques
    • tag dispatch
    • CRTP (Curiously Recurring Template Pattern)
    • expression templates
    • policy-based design
  • Performance Optimization

    Cache-friendly data structures, branch prediction, SIMD intrinsics, profiling tools (perf, valgrind, sanitizers), benchmarking, compiler optimizations, link-time optimization, profile-guided optimization

    Objectives

    • Profile and optimize C++ programs systematically
    • Apply cache-friendly and SIMD optimizations

    Key concepts

    • cache-friendly data structures
    • branch prediction hints
    • SIMD intrinsics
    • profiling (perf, valgrind)
    • sanitizers (ASan, TSan, UBSan)
    • compiler optimizations (-O2, -O3)
    • link-time optimization (LTO)
    • profile-guided optimization (PGO)
  • Build Systems & Tooling

    CMake, compilation model (preprocessing, compilation, linking), header files and include guards, static vs dynamic libraries, package managers (Conan, vcpkg), cross-compilation, sanitizers

    Objectives

    • Configure builds with CMake effectively
    • Understand the C++ compilation and linking model

    Key concepts

    • CMake (CMakeLists.txt, targets, properties)
    • compilation model (preprocessing, compilation, linking)
    • header guards and #pragma once
    • static vs dynamic libraries (.a/.so/.dll)
    • Conan / vcpkg package managers
    • cross-compilation
    • compilation flags and warnings
    • ABI compatibility

Levels: Junior, Mid, Senior, and Expert

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying C/C++?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying C/C++?

Start with C Fundamentals: Variables & Types, Control Flow, and Functions. The map orders topics by what they depend on, so each one prepares the next.

How long does a full C/C++ assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.