Free to read ยท Three levels

Modern C++20: values, ownership, and reliable systems

A complete theory-led path from the first compiled program to safe ownership, generic interfaces, concurrency, and measured API design.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Learn modern C++ through explicit contracts, original worked programs, diagnostic reasoning, and solved practice. Eighteen substantial lessons build a consistent model of values, object lifetimes, and resource ownership before introducing more advanced abstractions.

The baseline is C++20 with a conforming standard library. Every runnable program is complete and independent; thread examples also need the platform thread build option. Outputs describe defined successful executions, never a promised result for undefined behavior. Compiler and library availability are checked separately, and later-standard features are identified explicitly.

What you will learn

  • Write initialized, bounded, and testable C++20 value-oriented programs.
  • Apply RAII and modern ownership across containers, callbacks, and interfaces.
  • Use standard algorithms, concepts, and ranges with valid lifetime contracts.
  • Design race-free concurrency and evaluate performance with reproducible evidence.

Your learning path

Three levels

Basic

Build C++20 programs with initialized values, validated control flow, and owning value types.

  1. Build and understand a C++20 program
  2. Values, types, and safe initialization
  3. Control flow and validated input
  4. Functions, references, and contracts
  5. Strings, vectors, and valid access
  6. Classes, invariants, and composition
Explore this level

Intermediate

Manage ownership and state safely while composing algorithms and a repeatable development workflow.

  1. RAII, lifetimes, and smart pointers
  2. Copy, move, and value semantics
  3. Algorithms, iterators, and containers
  4. Templates, lambdas, and reusable operations
  5. Exceptions and state guarantees
  6. Build, test, and debug systematically
Explore this level

Advanced

Design constrained generic interfaces, safe views, polymorphic resources, and synchronized programs using measured tradeoffs.

  1. Concepts and generic contracts
  2. Ranges, views, and borrowing
  3. Resource safety across ownership boundaries
  4. Polymorphism and alternative designs
  5. Concurrency and synchronization
  6. Performance measurement and API design
Explore this level

Who this is for

  • Self-study learners building a first rigorous C++ foundation.
  • Programmers moving from other languages into explicit lifetime and resource reasoning.

Before you start

  • Basic computer and terminal use; no previous C++ knowledge is required for the basic level.
  • A C++20 compiler and standard library; GCC/Linux command examples assume a Unix-like shell.

Related technical solutions

Fix undefined references and missing template definitionsSeparate a linker failure from a compiler rejection, then establish that the matching definition is compiled, visible when needed, and included in the target.Repair dangling references and use-after-freeFind the owner behind a pointer, reference, or view, then redesign the lifetime relationship instead of relying on text that happened to remain in dead storage.Fix iterator invalidation after container changesIdentify the exact modifying operation and container rule, then choose a traversal that remains valid as elements move or are erased.