Home / C++ / Curriculum

THE COMPLETE LEARNING MAP

C++: from your first program to modern C++

Designed for learners who have never programmed before. It moves from simple ideas to technical detail in a careful order. You will learn what to type and what the compiler, program, memory, and standard library are doing.

Language style: simple English, correct technical vocabulary, short definitions, diagrams, small examples, and step-by-step traces. Technical words are explained when first introduced.

Honest publication status: links marked Published are available now. Topics marked Planned are part of the target syllabus but are not yet published lessons.

How to study

  1. Follow modules in order if C++ is new to you.
  2. Type every example into your compiler. Predict output before running it.
  3. Read compiler errors carefully and explain the cause before changing code.
  4. Complete exercises without viewing answers first; test boundary cases.
  5. Use reference links for exact rules, not as a replacement for guided lessons.

Study-time estimates: these timings estimate active study, not passive reading alone. They include reading, code walkthroughs, and completing the lesson's practice. Actual time varies with prior experience and how thoroughly you test each example.

Module 1 — Programming foundations and toolchain

Understand programs before syntax, then set up the tools you need to build and run your first example.

  1. Published — What programming is: turning a problem into instructions
  2. Published — Why programming languages exist
  3. Published — From C++ source code to an executable
  4. Published — How a C++ program starts and executes
  5. Published — Install and use a C++ compiler
  6. Published — Your first C++ program, explained line by line

Module 2 — Variables, types, input, and output

Represent information and communicate with users.

  1. Published — Variables, values, and data types
  2. Published — Input and output with iostream
  3. Published — Initialization, assignment, and constants
  4. Published — Integer ranges, signedness, and floating-point precision
  5. Published — Type conversions, auto, and sizeof

Module 3 — Operators and expressions

  1. Published — Expressions, arithmetic, and deliberate conversions
  2. Published — Comparison, logical, and bitwise operators
  3. Published — Assignment, increment, and decrement
  4. Published — Bit manipulation and bit flags
  5. Published — Operator precedence and associativity
  6. Published — Explicit casts and safe numeric conversions

Module 4 — Decisions and loops

  1. Published — Making choices with if and switch
  2. Published — Repeating work with loops
  3. Published — Nested loops and iteration patterns
  4. Published — Loop control, input validation, and dry runs
  5. Published — Compiler warnings, debugging, and testing

Module 5 — Functions and program organisation

  1. Published — Functions, parameters, and return values
  2. Published — Declarations, definitions, and header files
  3. Published — Passing arguments: value, reference, and pointer
  4. Published — Scope, lifetime, and storage duration
  5. Published — Function overloading, declarations, and namespaces
  6. Published — Recursion and the function call stack

Namespace basics are introduced in Function design; advanced one-definition-rule (ODR) cases are not yet covered in this course.

Module 6 — Arrays, strings, and user-defined data

  1. Published — Arrays and indexed storage
  2. Published — Fixed-size sequences with std::array
  3. Published — Multidimensional arrays and nested loops
  4. Published — Text with std::string
  5. Published — C-style strings and character arrays
  6. Published — Structures, enumerations, and type aliases
  7. Published — Dynamic sequences with std::vector
  8. Published — Advanced dry runs and off-by-one errors

Module 7 — Pointers, references, and object lifetime

  1. Published — Pointers and memory addresses
  2. Published — References and const references
  3. Published — Pointer arithmetic, arrays, and safe interfaces
  4. Published — Object lifetime and dangling references

Module 8 — Classes, ownership, and object-oriented design

  1. Published — Classes and objects
  2. Published — Constructors, destructors, and invariants
  3. Published — Class design: access control, this, and static members
  4. Published — Const correctness and member functions
  5. Published — Class invariants, static members, and friends
  6. Published — Composition, encapsulation, and operator overloading
  7. Published — Inheritance, virtual functions, and polymorphism
  8. Published — Dynamic memory, RAII, and smart pointers
  9. Published — Abstract classes and virtual destructors
  10. Published — Pointer ownership and resource management
  11. Published — Copying, moving, and the Rule of Zero

Module 9 — Templates and the C++ standard library

Learn the generic-programming idea behind standard-library containers, then choose containers and algorithms based on the operations your program needs.

  1. Published — Function and class templates
  2. Published — Stacks, queues, deques, and lists
  3. Published — Maps, sets, and unordered containers
  4. Published — Iterator categories and invalidation
  5. Published — Choosing STL containers by operations and complexity
  6. Published — STL algorithms, iterators, and lambdas
  7. Published — Lambda captures and predicates
  8. Published — Custom comparators and sorting
  9. Published — optional, variant, pair, and tuple

Module 10 — Files, input validation, errors, and robust programs

  1. Published — File input and output
  2. Published — String streams, parsing, and input validation
  3. Published — Robust menu-driven programs and input validation
  4. Published — Command-line arguments and program configuration
  5. Published — Exceptions and error handling
  6. Published — Assertions, preconditions, and defensive checks
  7. Published — Exception safety and resource-safe design
  8. Published — Working with paths and files using std::filesystem

Module 11 — Modern C++ and advanced library features

  1. Published — Modern C++11, C++14, C++17, and C++20
  2. Published — Advanced templates, type traits, and if constexpr
  3. Published — constexpr and compile-time programming
  4. Published — C++20 concepts and ranges
  5. Published — C++23 library features: expected and print
  6. Published — string_view and span: non-owning views
  7. Published — Time and clocks with std::chrono
  8. Published — Random numbers with the C++ random library
  9. Published — C++ concurrency: threads, mutexes, and race conditions
  10. Published — Async tasks, futures, and atomic operations
  11. Published — Condition variables and producer-consumer synchronization

Module 12 — Problem solving and projects

  1. Published — Complexity, testing, and C++ projects
  2. Published — STL algorithm patterns: two pointers, sliding windows, and prefix sums
  3. Published — Binary search and STL search algorithms
  4. Published — Priority queues and heaps
  5. Published — STL complexity and problem-solving patterns
  6. Published — Project: build a calculator and unit converter
  7. Published — Project: Student record manager with files and vectors
  8. Published — Project: Inventory management with classes and STL
  9. Published — Build multi-file C++ projects with CMake
  10. Published — Unit testing C++ programs with CTest
  11. Published — Debugging C++ with GDB, AddressSanitizer, and UBSan
  12. Published — Capstone: build a tested library catalogue CLI

Technical reference library

Publication rule: a topic is not marked Published until its lesson has been written, code checked, examples explained, practice added, references verified, and links tested. This roadmap is the target syllabus, not a claim that every planned lesson is ready.