World Atlas
Explore 115 study topics across 4 continents and 13 tracks. Search by title, ISO clause, or /w/cpp path, trace prerequisite routes, switch to dependency columns, or browse 115 concept maps and 12 interactive debuggers below.
- Not read yet
- Read
- Debugger
- Next up
- Land route
- Sea crossing
115 topics in 13 tracks
Concept-map folio
Each town on the world map expands into a concept tree and reading guide, arranged below across the four continents.
Language basics
Program structure
How source text becomes an executable: translation units, linkage, name lookup and modules.
Translation Units, ODR, and Linkage
The one-definition rule
Name Lookup, Qualified Lookup, and ADL
Namespaces and scope
C++20 Modules
The preprocessor and translation phases
Attributes
Program startup and termination
Types and initialization
What a type promises, how values convert, and every spelling of initialization and deduction.
Fundamental types and arithmetic conversions
Implicit conversions
Casts and cv-qualifiers
Casts
const, volatile and qualifiers
Initialization Forms in C++
Aggregates and designated initializers
Type Deduction: auto, decltype, and CTAD
Enumerations and unions
Value semantics
What an expression means, when resources move, and when copies disappear at the language level.
Expressions and functions
Evaluation order guarantees, compile-time execution, closure types and overload resolution.
Evaluation Order, Sequencing & Undefined Side Effects
Constant Expressions: constexpr, consteval & constinit
Lambdas: Closure Types, Captures & Generic Parameters
Overload Resolution: Candidates, Viability & Ranking
Operator overloading
Three-way comparison
Function parameters and default arguments
Structured bindings
Building abstractions
Classes
Subobject construction order, dynamic dispatch machinery and deterministic RAII.
Member functions and this
Constructors & Member Initialization Order
Inheritance and Virtual Functions
Multiple and virtual inheritance
Access control and friends
Conversion functions and explicit
Pointers to members
RAII and Resource Management
Templates
Forwarding references, SFINAE, C++20 concept subsumption and C++23 explicit object parameters.
Template instantiation and specialization
Template argument deduction
Dependent names and two-phase lookup
Variadic templates and fold expressions
SFINAE and Concepts
SFINAE
Concepts and constraints
Forwarding References and Perfect Forwarding
Class template argument deduction
Type traits and metaprogramming
CRTP and Deducing This
Non-type template parameters
Partial ordering of templates
Exceptions and error handling
Stack unwinding, exception-safety guarantees and value-based error handling with expected.
The machine
Memory model
Storage duration, object lifetime, strict aliasing, multi-core atomics and smart-pointer control blocks.
Object lifetime and storage
Object layout and alignment
Strict aliasing and undefined behavior
Strict aliasing and undefined behavior
Atomics and memory ordering
Dynamic allocation with new and delete
Smart pointers, control blocks, and allocators
Smart pointers
Allocators and polymorphic memory resources
Pointers, arrays and pointer arithmetic
Concurrency
Cooperative cancellation with jthread, synchronization primitives and C++20 coroutines.
Threads, jthread, cooperative stop, and locks
Threads and jthread
Mutexes and locks
Condition variables and waiting
Futures, promises and async
C++20 coroutines and C++23 std::generator
Coroutine library and generators
Lock-free programming and ABA
Parallel algorithms and execution policies
Library and C++26
Containers and strings
Memory layouts, iterator invalidation contracts, small-string optimization and non-owning views.
Containers, memory layouts, and iterator invalidation
Sequence containers
Associative and unordered containers
Iterator invalidation
Container adaptors and flat containers
Strings, string_view, and span
Strings and string_view
span and mdspan
Node handles and heterogeneous lookup
array, bitset and vector<bool>
Iterators, algorithms and ranges
Iterator concepts, lazy range adaptors, borrowed ranges and customization point objects.
Iterator categories and concepts
The algorithm library
Ranges, views, and niebloids
Ranges and views
Borrowed ranges and dangling
Range adaptors and pipelines
Strict weak ordering and comparators
Customization points and niebloids
Iterator adaptors and sentinels
Library utilities
Type-safe unions, callable wrappers and compile-time checked formatting.
Vocabulary types and std::format
optional, variant and any
pair, tuple and the tuple protocol
Callable wrappers
chrono
std::format and std::print
Iostreams
std::filesystem
Random numbers
Floating point and numerics
Bit manipulation
Character types and Unicode
Integer arithmetic and overflow
C++26
Contracts, static reflection, structured concurrency with std::execution and erroneous behavior.