Input diagnostics tool
Read typed input, reject invalid values, and present a clear report with documented compiler commands.
Review evidence: Valid and invalid transcripts, warning-clean build, and an explanation of each validation rule.
All courses
Free course · 50 lessons availableBeginner → intermediate
C++ Tutorial for Beginners: Learn Modern C++
Learn through clear explanations, code practice and quizzes across all 50 lessons. Build from your first program to modern C++, tested CMake projects and a documented command-line interface.
50 lessons available 10 units 5 project briefs
Start the first lesson Learn modern C++Values · Ownership · Reliable software
THE LEARNING PATH Milestone project · Planned Milestone project · Planned Milestone project · Planned Milestone project · Planned Milestone project · Planned Final practice · Planned HOW TO USE THE ROADMAP
From a first build to a program you can maintain.
Start from the beginning without prior C knowledge. Basic computer and terminal familiarity helps; learners coming from C, Python, or JavaScript can use the roadmap to identify unfamiliar concepts.
Publication status: All 50 instructional lessons are available. Start with the introduction below. The five milestone projects are still briefs; their detailed tutorials, the assessment and the capstone remain planned, separate from the lesson count.
01
Get a program running
Explain the edit → compile → link → run loop and keep a reproducible development setup.
01 · C++ Introduction: What Is C++?Available
Understand compiled programs, the language versus its standard library, and the course's value-first approach.
Practice target: Map a command-line tool's inputs, transformations, outputs, and possible failures.
Read lesson02 · How to Install a C++ Compiler and Set Up Your EditorAvailable
Choose a Windows, macOS, or Linux toolchain and verify the selected compiler and C++ language mode.
Practice target: Record your compiler version and compile a tiny program from the terminal, not only an IDE button.
Read lesson03 · C++ Hello World: Your First Program ExplainedAvailable
Read headers, main, statements, namespaces, and console output without treating the program as magic.
Practice target: Print a three-line introduction and explain each part of the source file.
Read lesson04 · How to Compile and Run C++ ProgramsAvailable
Distinguish preprocessing, compilation, linking, and execution; identify the first useful diagnostic.
Practice target: Introduce a syntax error and a missing definition, then classify and repair both failures.
Read lesson05 · C++ Debugging: Warnings and BreakpointsAvailable
Use warnings and a debugger to inspect actual state before changing a program based on guesses.
Practice target: Step through an incorrect total, inspect intermediate values, and write the cause before fixing it.
Read lesson
02
Work with values and input
Represent data deliberately and keep invalid input from becoming hidden program state.
06 · C++ Variables: Initialization and ScopeAvailable
Compare declaration with initialization and trace the visibility and lifetime of local variables.
Practice target: Rewrite uninitialized local variables with explicit initial values and reduce their scopes.
Read lesson07 · C++ Data Types: int, double and Type ConversionAvailable
Reason about integer division, signedness, range, narrowing, and floating-point approximation.
Practice target: Calculate an average without accidental integer division and explain why money needs a deliberate representation.
Read lesson08 · C++ const, constexpr and auto ExplainedAvailable
Separate immutability, compile-time constants, and type deduction rather than treating them as interchangeable shortcuts.
Practice target: Mark stable settings const and use auto only where the initializer makes the type clear.
Read lesson09 · C++ Operators: Arithmetic, Comparison and LogicAvailable
Read arithmetic, comparison, logical operations, precedence, and short-circuit evaluation.
Practice target: Write a delivery eligibility rule with named intermediate conditions and boundary cases.
Read lesson10 · C++ User Input: cin, getline and ValidationAvailable
Distinguish formatted extraction from line input and handle stream failure without an endless retry loop.
Practice target: Accept an integer in a permitted range and recover from a non-numeric input line.
Read lesson
03
Control flow and functions
Turn a problem into small decisions, bounded repetition, and functions with clear contracts.
11 · C++ Conditions: if, else if and elseAvailable
Learn if, else if and else with Boolean conditions, nested branches and guard clauses; test exact decision boundaries.
Practice target: Classify a ticket request with if/else and test below, at and above each threshold.
Read lesson12 · C++ Switch Statement: Cases, break and defaultAvailable
Choose switch for discrete integral or enum cases, understand fallthrough and compare it with an if/else chain.
Practice target: Build a menu dispatcher with explicit cases, break and a default for unsupported commands.
Read lesson13 · C++ For Loop: Syntax and ExamplesAvailable
Trace initialization, condition and update in a for loop; practise counters, nested loops and off-by-one checks.
Practice target: Generate a multiplication table and test zero, one and several iterations without reading past a bound.
Read lesson14 · C++ While and Do-While Loops: ExamplesAvailable
Compare entry-tested while and exit-tested do-while loops; use break and continue with explicit termination rules.
Practice target: Build a bounded menu loop that exits on a command or end-of-input, then explain when its body runs.
Read lesson15 · C++ Functions: Parameters and Return ValuesAvailable
Define functions with clear contracts, compare value and reference parameters, and introduce overloads and default arguments.
Practice target: Extract a price calculation into a pure function; explain its parameters and test normal and boundary cases.
Read lesson
04
Strings and sequences
Use owning library types before manual storage, and reason about bounds and invalidation.
16 · C++ Strings: std::string with ExamplesAvailable
Create, compare, search, and slice strings while distinguishing bytes from user-perceived characters.
Practice target: Normalize a simple ASCII command and reject empty input without claiming Unicode normalization.
Read lesson17 · C++ Vector: std::vector with ExamplesAvailable
Use a dynamic owning sequence and distinguish size, capacity, element access, and bounds checks.
Practice target: Collect scores, reject invalid entries, and compute a report for empty and non-empty input.
Read lesson18 · C++ Arrays: std::array and Bounds CheckingAvailable
Choose std::array for fixed-size data and identify invalid indices before they reach element access.
Practice target: Model seven daily readings and validate an external day index.
Read lesson19 · C++ Range-Based For Loop and IteratorsAvailable
Traverse values without unnecessary copies and recognize operations that invalidate iterators or references.
Practice target: Filter a vector safely and explain why erasing while incrementing blindly skips or invalidates work.
Read lesson20 · C++ Vector Practice: Build a Data SummaryAvailable
Combine input, validation, transformation, and reporting without mixing every responsibility in one loop.
Practice target: Build a reading summary with count, minimum, maximum, and an explicitly handled empty case.
Read lesson
Reading analyzer
Organize readings in a vector, extract pure functions, and handle empty input and boundary values.
Review evidence: Expected outputs for empty, single-value, and mixed readings, plus a responsibility map for the functions.
05
Model data with classes
Express valid states through small types and prefer ordinary value semantics over unnecessary hierarchy.
21 · C++ Structs and enum class ExplainedAvailable
Group related data and replace unexplained numeric or string flags with scoped domain states.
Practice target: Model a task record with a scoped status and explicit display labels.
Read lesson22 · C++ Classes and Objects: EncapsulationAvailable
Use a type's public interface to protect rules rather than exposing arbitrary mutations.
Practice target: Design a bounded quantity type that cannot silently hold a negative value.
Read lesson23 · C++ Constructors and Member InitializationAvailable
Initialize members deliberately, respect declaration order, and describe what a constructed object guarantees.
Practice target: Create an inventory item whose identifier and starting quantity are validated at construction.
Read lesson24 · C++ Const Member Functions and CompositionAvailable
Distinguish observing an object from changing it, and build larger behavior by composing smaller types.
Practice target: Compose an order from line items and make read-only queries callable on const objects.
Read lesson25 · C++ Copying Objects and the Rule of ZeroAvailable
Reason about independent copies while relying on standard-library members for resource management.
Practice target: Copy a record containing a string and vector, mutate the copy, and explain the independence.
Read lesson
06
Lifetime and resource ownership
Make ownership explicit and recognize dangling access before considering low-level optimization.
26 · C++ Object Lifetime, Destructors and RAIIAvailable
Connect scope exit and destructors to deterministic cleanup, including early return and exception paths.
Practice target: Trace the construction and destruction order of nested objects using a small logging type.
Read lesson27 · C++ Pointers and References: nullptr and BorrowingAvailable
Compare values, const references, mutable references and non-owning pointers; distinguish optional access from ownership.
Practice target: Compare value and reference parameters, then check an optional pointer lookup for nullptr before accessing it.
Read lesson28 · C++ unique_ptr: Smart Pointers and OwnershipAvailable
Represent a dynamically allocated object's single owner without routine manual new/delete pairs.
Practice target: Transfer an exclusively owned object and demonstrate that copying ownership is rejected.
Read lesson29 · C++ Move Semantics: std::move vs CopyingAvailable
Understand move-enabled operations, valid moved-from states, and why std::move itself does not move anything.
Practice target: Trace a copy and a move, then reset and reuse a moved-from library object safely.
Read lesson30 · C++ string_view and span: Avoid Dangling ViewsAvailable
Distinguish owning data from std::string_view and std::span, which do not extend the underlying lifetime.
Practice target: Identify a returned dangling view and redesign the interface with a valid owner or an owning return value.
Read lesson
Inventory domain model
Protect item invariants with value types and demonstrate safe ownership and lifetime boundaries.
Review evidence: Copy/move scenarios, invalid construction cases, and a diagram explaining who owns each resource.
07
Containers and algorithms
Choose a collection by the work it must support and use algorithms with valid range contracts.
31 · C++ map vs unordered_map: Lookup and ExamplesAvailable
Compare ordered and hash-based maps, missing keys, insertion, and read-only lookup behavior.
Practice target: Build a word-frequency report and avoid accidentally inserting during a lookup.
Read lesson32 · C++ set, queue and stack: When to Use EachAvailable
Choose uniqueness or processing-order abstractions instead of forcing every problem into a vector.
Practice target: Model a unique tag list and a first-in-first-out processing queue.
Read lesson33 · C++ Lambda Expressions and STL AlgorithmsAvailable
Use find, count, transform, and predicates; explain captures and their lifetime requirements.
Practice target: Filter and summarize records with small predicates whose captures remain valid.
Read lesson34 · C++ sort and binary_search: Rules and ComplexityAvailable
Respect sorted-range preconditions and strict ordering while comparing linear and logarithmic search costs.
Practice target: Sort records by a defined key, search the sorted data, and explain when binary search is invalid.
Read lesson35 · C++20 Ranges: Views, filter and transformAvailable
Read filter/transform pipelines and distinguish a lazy view from a materialized owning result.
Practice target: Build a small range pipeline and keep the underlying container alive until iteration finishes.
Read lesson
08
Errors, files, and interfaces
Keep failure visible at system boundaries and select explicit representations for missing or alternative data.
36 · C++ optional and variant ExplainedAvailable
Use std::optional for absence and std::variant for a closed set of alternatives without sentinel values.
Practice target: Parse a lookup request and distinguish a missing result from a valid zero value.
Read lesson37 · C++ Exceptions: try, catch and Safe CleanupAvailable
Separate normal alternatives from exceptional failure and reason about cleanup without swallowing errors.
Practice target: Handle a failed load at the application boundary while leaving domain objects unchanged.
Read lesson38 · C++ File Handling: Read and Write Text FilesAvailable
Read and write text files, check stream state, and use filesystem paths without assuming one operating system.
Practice target: Load a small data file and report missing files and failed writes explicitly.
Read lesson39 · C++ Input Parsing and Data ValidationAvailable
Separate syntax checks from domain rules and reject partial or malformed input deliberately.
Practice target: Parse a restricted record format, reject extra fields, and report the offending line number.
Read lesson40 · C++ Polymorphism: Virtual Functions and InterfacesAvailable
Use virtual interfaces only when substitution is needed; understand overriding, slicing, and virtual destruction.
Practice target: Compare a composed storage adapter with a small polymorphic interface and justify the simpler design.
Read lesson
Searchable file-backed catalog
Load validated records, query by key, sort results, and report persistence failures explicitly.
Review evidence: Malformed-file fixtures, missing-key cases, and a documented recovery policy for failed writes.
09
Generic programming and quality
Write reusable typed behavior and verify it with repeatable checks instead of output inspection alone.
41 · C++ Templates: Function and Class ExamplesAvailable
Express type-independent behavior and recognize when a concrete function remains easier to understand.
Practice target: Write a small generic helper, instantiate it with two types, and inspect an invalid instantiation.
Read lesson42 · C++20 Concepts and Template ConstraintsAvailable
State template requirements with C++20 concepts and distinguish a syntactic constraint from semantic correctness.
Practice target: Constrain a helper and explain both an accepted type and a rejected type.
Read lesson43 · C++ Unit Testing: Normal and Boundary CasesAvailable
Design deterministic tests around observable contracts, including empty, invalid, and exact-boundary inputs.
Practice target: Test pure inventory rules independently of files, the terminal, and the current clock.
Read lesson44 · C++ Sanitizers: Find Memory and Undefined Behavior BugsAvailable
Use supported diagnostics to find memory and undefined-behavior bugs without treating a clean run as a proof.
Practice target: Investigate a deliberately isolated invalid-access example with a supported sanitizer configuration.
Read lesson45 · C++ Performance: Benchmark Before OptimizingAvailable
Separate algorithmic cost from micro-optimization and design a benchmark that checks correctness first.
Practice target: Compare two lookup approaches on representative input and report environment and measurement limits.
Read lesson
10
Build and deliver a complete application
Connect source organization, tooling, tests, and documentation into a reproducible release workflow.
46 · C++ Header Files and Translation UnitsAvailable
Separate declarations from definitions, use include guards, and diagnose duplicate or missing symbols.
Practice target: Split domain code into a header and source file without including implementation files.
Read lesson47 · C++ CMake Tutorial: Build an ExecutableAvailable
Define target-level sources, include paths, language requirements, and an out-of-source build.
Practice target: Configure and build an executable from a clean build directory with an explicit C++ standard.
Read lesson48 · C++ Dependencies and CTest: Automated TestsAvailable
Keep dependency decisions reproducible and register tests so one command can verify a clean checkout.
Practice target: Register focused tests with CTest and document how dependencies are obtained.
Read lesson49 · C++ Multithreading: Threads and Data RacesAvailable
Recognize data races and scope-bound thread management; introduce synchronization without promising parallel speedups.
Practice target: Review a shared counter, identify the race, and compare a synchronized design with avoiding shared state.
Read lesson50 · C++ Command-Line Applications: Help and Release ChecksAvailable
Define commands, exit codes, help text, data safety, and a repeatable build/test checklist.
Practice target: Review a clean checkout against a README, test report, failure cases, and known limitations.
Read lesson
Tested multi-file command-line tool
Package domain logic, storage, and command handling into CMake targets with automated tests.
Review evidence: Clean build instructions, CTest output, supported diagnostic checks, and a concise user guide.
Cumulative C++ assessment
Explain lifetime and ownership, repair a failing program, select a suitable container, and justify a test plan. Planned; no score or certificate is currently issued.
Capstone: a reliable inventory CLI
Build add, list, find, and update commands with validated records, file persistence, explicit error handling, automated tests, and reproducible CMake setup. Delivery includes a README and design review, not only source code.
Practice is part of the lesson, not an optional extra.
Move through units in order if C++ is new to you. Before running an example, predict the result. Compile with warnings enabled, change one assumption, and explain what happened. Keep small experiments in Git so you can compare your reasoning with the actual diff.
At each milestone, work from the brief before looking at a solution. Keep normal, empty, invalid, and boundary cases. A program that runs once is not evidence that its lifetime rules, input handling, and failure paths are correct.
What to expect in the lessons
- Learning objectives and prerequisite links.
- A visual mental model and substantial explanation.
- Annotated examples with local build/run instructions and expected results.
- Common mistakes, failure cases and repair reasoning.
- An independent lab with acceptance criteria and an explained solution.
- A knowledge check, recap and previous/next navigation.
Scope and tooling
C++20 teaching baseline, with standard-library-first examples and explicit compiler-support notes. Newer features will be clearly labelled, not silently required. A local compiler is required for full-language exercises; selected beginner examples use a clearly limited browser interpreter. Shared ownership, templates, concurrency, and performance are introduced after lifetime fundamentals. GUI frameworks, game engines, networking libraries, and advanced lock-free programming are outside this first course.
Reference shelf
- C++ Core Guidelines — Design guidance for interfaces, ownership, resource management, and safety.
- Microsoft C++ language reference — Language reference and toolchain-specific explanations for MSVC.
- CMake tutorial — Official build-system tutorial; check its prerequisites and version-specific details.