Beginner
Start here if you are new to C++. This track builds core syntax, control flow, functions, data, and reliable program structure.
Getting Started
- Program Structure
Understand what a minimal C++ program looks like and what each line actually does.
- Variables & Types
Learn how C++ stores integers, decimals, characters, booleans and text.
- Input & Output
Read data from the user and display results.
- Conditions
Make your programs choose what to do using if, else if and else.
Control Flow & Functions
- Loops
Repeat work efficiently with for and while loops.
- Functions & Arrays
Organize reusable logic and store groups of values.
- Operators & Expressions
Learn how arithmetic, comparison, logical and assignment operators combine into expressions.
- Variable Scope
Understand where variables exist and where they can be accessed.
Data & Containers
- std::string Basics
Work confidently with text using the C++ standard string type.
- std::vector Basics
Use a resizable sequence instead of fixed-size arrays when the amount of data can change.
- Read-Only Values & auto
Use const to protect values and auto to keep obvious or verbose types readable.
More Control Flow
- switch Statements
Handle several exact-value branches cleanly with switch.
- do-while Loops
Learn the loop that always runs its body at least once.
- break & continue
Control loop execution more precisely.
- Validating Input with while
Use a while loop to recover from malformed input, reject values outside a range, and stop safely at end of input.
Functions & Custom Types
- Function Parameters & Return Values
Separate inputs, processing and outputs in reusable functions.
- Function Overloading
Give multiple functions the same name when their parameter lists differ.
- Enums
Represent a small fixed set of named choices.
- Structs
Group related pieces of data into your own simple type.
- Collections of Records
Combine structs and vectors to store and inspect a growing set of related records.
Project Structure & Debugging
- Header & Source Files
Split a growing program across .h/.hpp and .cpp files.
- Compiling & Linking
Follow source code through preprocessing, compilation, and linking.
- Command-Line Arguments
Read values supplied when someone starts a program from a terminal.
- Compiler Errors & Warnings
Learn to read compiler messages instead of guessing what went wrong.
- Testing & Debugging Small Programs
Separate build failures from behavior bugs, then check a small program with known cases.
- Beginner Project: Number Analyzer
Combine input, loops, functions and vectors into a small complete program.
Writing Reliable Code
- Comments & Readability
Write code that another programmer can understand quickly.
- Numeric Types & Limits
Choose numeric types deliberately and understand that every type has a range.
- Integer Overflow & Safe Arithmetic
Check integer bounds before arithmetic that could exceed a type's range.
- Type Conversions & Casting
Learn when C++ converts values automatically and when an explicit cast is clearer.
- Common Mathematical Functions
Use the standard math library for roots, powers, magnitudes, and rounding.
- Compound Assignment & Increment
Write common updates concisely with +=, -=, *=, /=, ++ and --.
Everyday Data & Logic
- std::string Operations
Go beyond storing text: measure, search, slice, and modify strings.
- Character Classification and Conversion
Classify individual characters and change their case with the cctype library.
- std::vector Operations
Learn the everyday operations used to grow, inspect, and remove vector elements.
- Search, Count, and Find Minimum or Maximum
Use one-pass loops to search values, count matches, and track an extreme value.
- Nested Loops
Use one loop inside another for grids, tables, and pairwise work.
- Multidimensional Arrays
Represent simple fixed-size grids with more than one array dimension.
- Random Numbers
Generate pseudo-random values with the modern <random> library.
Beginner Capstone
- Beginner Project: Guessing Game
Combine variables, loops, conditions, and random numbers into a complete mini-game.
Intermediate
Continue here after the fundamentals. This track develops classes, the standard library, errors, files, ownership, and object lifetime.
References, Pointers & Classes
- References
Work with an existing object without copying it.
- Pointers
Understand addresses, dereferencing and nullptr.
- Classes & Objects
Bundle state and behavior into your own types.
Polymorphism & STL Basics
- Inheritance & Polymorphism
Create related types and use virtual dispatch.
- STL Containers
Use vector, map, set and other battle-tested standard containers.
- Algorithms & Iterators
Sort, search and transform data using the standard library.
- Sorting & Searching with Comparators
Order records by multiple fields and search them with predicates.
- Transforming and Removing Elements
Use standard algorithms to derive values, count matches, and remove selected vector elements safely.
Class Design
- Constructors & Destructors
Control what happens when objects are created and destroyed.
- Access Control & static Members
Use public/private boundaries and data shared by every object of a class.
- const Correctness
Express which values and member functions are not allowed to modify state.
- Operator Overloading
Define natural operators for your own types when the meaning is clear.
Errors, Files & Namespaces
- Exceptions
Handle exceptional failures using throw, try and catch.
- Choosing an Error-Handling Strategy
Choose a failure-reporting approach based on how expected a failure is and who needs to handle it.
- File I/O
Read from and write to files with standard stream classes.
- Parsing Lines with String Streams
Parse complete lines and build formatted text with string streams.
- Namespaces
Organize names and avoid collisions in larger programs.
Iterators, Lookup & Callables
- Iterator Patterns
Understand iterators beyond basic begin/end usage.
- Maps, Sets & Lookup
Choose containers based on whether you need key/value storage or unique values.
- std::function & Callables
Store functions, lambdas and other callable objects behind one interface.
Ownership & Design
- Composition
Build larger classes by owning smaller objects instead of inheriting everything.
- Dynamic Memory: new & delete
Understand manual allocation so you can recognize why modern ownership tools are safer.
- Copy Semantics
Understand when objects are copied and why some classes need custom copy behavior.
- Testing Stateful Components
Use focused tests to verify class operations, rejected changes, and the invariants that protect object state.
- Intermediate Project: Inventory System
Combine classes, containers, file I/O and algorithms in one practical exercise.
Container Toolkit
- std::array, deque & list
Choose among several standard sequence containers instead of always reaching for vector.
- Iterator Categories and Algorithm Requirements
Match an algorithm to the operations its iterator category supports, and choose the right way to move through a range.
- std::unordered_map
Use hash-based key/value lookup when sorted ordering is not required.
Object Design & Lifetime
- Constructors in Depth
Use initializer lists, delegating constructors, and explicit constructors to build valid objects.
- Abstract Classes & Interfaces
Define common behavior that derived classes are required to implement.
- Virtual Destructors
Destroy derived objects correctly through base-class pointers.
- Object Lifetime & Ownership
Reason about when objects exist, who owns resources, and when references become invalid.
Non-Owning Views
- std::string_view
Pass read-only text without copying or owning it.
- std::span
Pass contiguous sequences without copying and without hard-coding the container type.
Systems Utilities
- std::filesystem
Work with paths, files, and directories using the standard library.
- Traversing Directories with std::filesystem
Create a small directory, inspect its entries safely, and produce stable output from a filesystem traversal.
- std::chrono & Timing
Represent durations and measure elapsed time using type-safe clocks.
Advanced
Use this track after intermediate C++. It covers templates, modern library tools, memory, performance, and concurrency.
Templates & Resource Ownership
- Templates
Write generic code that works with multiple types.
- RAII
Tie resource lifetime to object lifetime.
- Smart Pointers
Manage dynamic ownership without manual delete in most cases.
- Move Semantics
Transfer expensive resources instead of copying them.
Lambdas & Threads
- Lambdas
Create small callable functions exactly where you need them.
- Concurrency Basics
Start understanding threads, mutexes and synchronization.
Generic Programming
- Template Specialization
Customize generic behavior for a particular type when the general template is not enough.
- Perfect Forwarding
Preserve whether arguments are lvalues or rvalues through generic wrapper code.
- constexpr & Compile-Time Evaluation
Move eligible computations into compile time.
- Concepts
Constrain templates with readable requirements in C++20.
- Dependent Names and Two-Phase Lookup
Understand how templates defer checks for names that depend on their type arguments.
Modern Library Types
- Ranges
Use modern composable views and algorithms for data processing.
- std::optional & std::variant
Represent missing values and type-safe alternatives without magic sentinel values.
- std::expected & Explicit Errors
Represent either a result or an error value in modern C++.
Type Tools & Special Members
- Type Traits
Inspect and transform types at compile time.
- Type Erasure and Runtime Interfaces
Choose between compile-time templates, closed variants, and runtime type-erased interfaces.
- Rule of Zero / Five
Design ownership-aware classes with correct copy and move behavior.
Concurrency
- Atomics
Perform certain shared-memory operations without a data race.
- Mutexes & condition_variable
Coordinate threads that share state or need to wait for work.
- Futures & std::async
Receive a result from asynchronous work.
- Memory Model & Ordering
Understand the rules that make multithreaded memory accesses meaningful.
- Advanced Project: Thread-Safe Work Queue
Combine RAII, templates, condition variables and ownership into a realistic component.
Advanced Generic Patterns
- Variadic Templates
Write templates that accept a variable number of typed arguments.
- Fold Expressions
Reduce a parameter pack with a compact operator expression.
- Custom Iterators
Make your own types work naturally with range-based loops and algorithms.
- CRTP
Use the Curiously Recurring Template Pattern for compile-time polymorphism.
Modern Language Tools
- Coroutines
Pause and resume functions with C++20 coroutine machinery.
- Three-Way Comparison (<=>)
Generate consistent ordering comparisons with the C++20 spaceship operator.
Memory & Allocation
- Polymorphic Memory Resources
Control allocation strategy without changing a container's element interface.
Advanced Concurrency
- Latches & Barriers
Coordinate groups of threads using C++20 synchronization primitives.
Performance & Architecture
- Profiling & Performance
Measure before optimizing and reason about algorithmic cost, allocations, and data access.
- Undefined Behavior and Sanitizer Workflows
Recognize common undefined behavior and use sanitizers to expose defects during testing.
- Cache Locality and Data Layout
Arrange data around the access pattern so processors can use nearby memory efficiently.
- Advanced Project: Type-Safe Event Bus
Combine variants, visitors, templates, and structured event types into a reusable event system.
C++ projects
Apply course concepts in guided programs. Project descriptions on this page use the public project summaries.
- Console CalculatorFree
Build a calculator that performs several operations and handles invalid choices cleanly.
- Number Guessing GameFree
Turn the beginner guessing-game idea into a complete replayable console game.
- Mini Text AdventurePro
Create a small branching adventure with locations, choices, health, and a win/lose condition.
- Weather Station LogPro
Record whole-degree readings from weather stations, reject invalid entries, and search and summarize accepted readings.
- Text Statistics ToolPro
Summarize pasted text with counts, a longest word, and the most frequent letter.
- Inventory ManagerPro
Build a reusable inventory system that can add, remove, search, and update item quantities.
- Text Log AnalyzerPro
Read a line-oriented log, count records by level, and report malformed lines.
- Banking SystemPro
Model bank accounts with encapsulated state, validation, and transfers between objects.
- Character Save SystemPro
Serialize a character to disk and load the data back into a valid object.
- Floor Plan EstimatorPro
Parse room dimensions, compare room areas, and estimate flooring material and cost.
- Type-Safe Event SystemPro
Build an event dispatcher that routes strongly typed events to registered callbacks.
- Thread-Safe Job QueuePro
Build a queue that safely transfers jobs between producer and worker threads.
- LRU Response CachePro
Build a fixed-capacity cache that keeps recent weather API responses ready for a dashboard.
- Expression CalculatorPro
Parse spreadsheet-style expressions with variables, precedence, and explicit error results.
- Telemetry Ring BufferPro
Keep the latest sensor samples in fixed storage and summarize them through standard algorithms.
Free guides
Use these public guides to practice related topics and troubleshoot common compiler messages.
- Free guide: Loops
- Free guide: Input validation
- Free guide: Vectors
- Free guide: Integer overflow
- Free guide: Why std::getline skips input after std::cin
- Free guide: Vector subscript out of range
- Free guide: Undefined reference
- Free guide: Was not declared in this scope
- Free guide: No matching function for call
- Free guide: Multiple definition linker error
- Free guide: Expected semicolon
- Free guide: Expected primary-expression
- Free guide: Does not name a type
- Free guide: Invalid conversion from const char* to char
- Free guide: Control reaches end of non-void function
- Free guide: Signed and unsigned comparison warning
- Free guide: Terminate called after throwing