# C++ Atlas > 115 structured C++ study topics paired with an offline 1:1 copy of en.cppreference.com covering 6587 pages (5971 C++, 616 C) across 51 domains (CC-BY-SA 3.0 / GFDL). ## Plain Markdown & NotebookLM Ingestion - Complete study guide (all topics combined): https://cppatlas.com/api/notebook/topics-all - Every `/topics/` exposes clean Markdown (with concept map outline and quiz traps) at `/api/notebook/topic/`. - Every `/w/cpp/` and `/w/c/` page renders complete server-side semantic HTML (`
`), making direct URL ingestion reliable. - Every reference page also exposes clean Audio-Overview-ready Markdown at `/api/notebook/cpp/` (or `/api/notebook/c/` for C pages). ## Study Topics (with Concept Maps & Standardese Quizzes) - [Translation Units, ODR, and Linkage](https://cppatlas.com/topics/translation-units-and-linkage) — [Markdown](https://cppatlas.com/api/notebook/topic/translation-units-and-linkage): Trace how source files become translation units and how scope, storage duration, linkage, and the One Definition Rule govern symbol visibility across them. - [The one-definition rule](https://cppatlas.com/topics/one-definition-rule) — [Markdown](https://cppatlas.com/api/notebook/topic/one-definition-rule): Every entity gets one definition per translation unit, some get exactly one per program, and classes, inline functions and templates may be defined everywhere as long as every copy is the same. Most violations need no diagnostic, so they show up as wrong behaviour that changes with flags and link order. - [Name Lookup, Qualified Lookup, and ADL](https://cppatlas.com/topics/name-lookup-and-adl) — [Markdown](https://cppatlas.com/api/notebook/topic/name-lookup-and-adl): Trace how the compiler maps an identifier to candidate declarations across unqualified lookup, qualified lookup, Argument-Dependent Lookup, and two-phase template lookup. - [Namespaces and scope](https://cppatlas.com/topics/namespaces-and-scope) — [Markdown](https://cppatlas.com/api/notebook/topic/namespaces-and-scope): A scope is the stretch of program text where a declaration can be found by unqualified lookup, and a namespace is a scope you can name, reopen and nest. Points of declaration, shadowing, using-directives and inline namespaces all follow from a few precise rules. - [C++20 Modules](https://cppatlas.com/topics/modules) — [Markdown](https://cppatlas.com/api/notebook/topic/modules): Replace fragile textual header graphs with semantic module interfaces, controlled exports, module linkage, and clean boundaries around legacy headers. - [The preprocessor and translation phases](https://cppatlas.com/topics/preprocessor-and-translation-phases) — [Markdown](https://cppatlas.com/api/notebook/topic/preprocessor-and-translation-phases): Before any C++ is parsed, source text passes through splicing, tokenization and macro expansion. The preprocessor works on tokens, knows nothing of scopes or types, and follows a handful of exact rules that explain almost every macro surprise. - [Attributes](https://cppatlas.com/topics/attributes) — [Markdown](https://cppatlas.com/api/notebook/topic/attributes): Attributes annotate entities and statements with information the compiler may use. Unknown ones are ignored, standard ones in the wrong place are errors, and a few of them are promises that cause undefined behavior when broken. - [Program startup and termination](https://cppatlas.com/topics/program-startup-and-termination) — [Markdown](https://cppatlas.com/api/notebook/topic/program-startup-and-termination): Before main runs, every static variable is zero- or constant-initialized and then dynamically initialized in a partly specified order. After it, std::exit unwinds that work in reverse, interleaved with atexit handlers, while quick_exit, abort and terminate each skip different parts. - [Fundamental types and arithmetic conversions](https://cppatlas.com/topics/fundamental-types-and-arithmetic-conversions) — [Markdown](https://cppatlas.com/api/notebook/topic/fundamental-types-and-arithmetic-conversions): The standard promises minimum widths and an ordering of integer types, not exact sizes, and every arithmetic operator first promotes small operands to int and then pulls both sides to a common type. Most signed and unsigned surprises fall out of those two steps. - [Implicit conversions](https://cppatlas.com/topics/implicit-conversions) — [Markdown](https://cppatlas.com/api/notebook/topic/implicit-conversions): An implicit conversion is a short, fixed pipeline of standard conversions, optionally wrapped around exactly one user-defined conversion. Knowing the slots in that pipeline explains why some conversions happen silently, why narrowing is banned only in braces, and why a second user-defined step is never taken. - [Casts and cv-qualifiers](https://cppatlas.com/topics/casts-and-qualifiers) — [Markdown](https://cppatlas.com/api/notebook/topic/casts-and-qualifiers): What const and volatile actually guarantee, why multi-level pointer conversions restrict const, and how to pick the narrowest C++ cast without breaking strict aliasing. - [Casts](https://cppatlas.com/topics/casts) — [Markdown](https://cppatlas.com/api/notebook/topic/casts): Each named cast is a narrow permission. static_cast performs conversions the type system can check, const_cast only changes qualifiers, reinterpret_cast reuses a value's bits or address under a different type, and dynamic_cast asks the object at run time. A C-style cast tries them in a fixed order and takes the first that compiles. - [const, volatile and qualifiers](https://cppatlas.com/topics/const-volatile-and-qualifiers) — [Markdown](https://cppatlas.com/api/notebook/topic/const-volatile-and-qualifiers): A cv-qualifier attaches to one level of a type, and whether it is top-level or buried inside a pointer decides what it protects, what is ignored, and which conversions are safe. const promises nothing about pointees, modifying a const object is undefined, and volatile is about observable accesses, not threads. - [Initialization Forms in C++](https://cppatlas.com/topics/initialization-forms) — [Markdown](https://cppatlas.com/api/notebook/topic/initialization-forms): Decode default, value, zero, direct, copy, aggregate, and list initialization—and prevent the narrowing, most-vexing-parse, and initializer_list traps. - [Aggregates and designated initializers](https://cppatlas.com/topics/aggregates-and-designated-initializers) — [Markdown](https://cppatlas.com/api/notebook/topic/aggregates-and-designated-initializers): An aggregate is a type the compiler initializes member by member with no constructor in charge. Its definition was rewritten in every standard from C++11 to C++20, and C++20 added designated initializers, parenthesized aggregate initialization and deduction for aggregate templates. - [Type Deduction: auto, decltype, and CTAD](https://cppatlas.com/topics/type-deduction-auto-decltype) — [Markdown](https://cppatlas.com/api/notebook/topic/type-deduction-auto-decltype): Master template-style auto deduction, the braced-initializer exception, decltype's two-rule split, structured bindings, and Class Template Argument Deduction. - [Enumerations and unions](https://cppatlas.com/topics/enumerations-and-unions) — [Markdown](https://cppatlas.com/api/notebook/topic/enumerations-and-unions): An enumeration is an integer type with named values and a precisely defined set of valid values; a union is storage for one of several objects at a time. Both are easy to misuse, because the language lets you hold values and read members it has not promised you. - [Value categories](https://cppatlas.com/topics/value-categories) — [Markdown](https://cppatlas.com/api/notebook/topic/value-categories): Replace circular left-of-equals folklore with C++17's two orthogonal expression axes—identity and movability—plus temporary materialization and decltype probes. - [Copy and move semantics](https://cppatlas.com/topics/copy-and-move) — [Markdown](https://cppatlas.com/api/notebook/topic/copy-and-move): How std::move grants permission without moving bytes, when user-declared special members suppress moves, why noexcept unlocks O(1) vector growth, and C++23 simpler implicit move. - [Copy elision and NRVO](https://cppatlas.com/topics/copy-elision) — [Markdown](https://cppatlas.com/api/notebook/topic/copy-elision): Why C++17 guaranteed prvalue elision eliminates moves by language semantics rather than optimization, and how optional NRVO breaks when you write return std::move(x). - [Reference binding and temporaries](https://cppatlas.com/topics/reference-binding-and-temporaries) — [Markdown](https://cppatlas.com/api/notebook/topic/reference-binding-and-temporaries): Which expressions bind to T&, const T&, and T&&, when implicit conversions silently materialize fresh temporaries, why lifetime extension stops at function boundaries, and C++23 range-for fixes. - [Evaluation Order, Sequencing & Undefined Side Effects](https://cppatlas.com/topics/evaluation-order) — [Markdown](https://cppatlas.com/api/notebook/topic/evaluation-order): Separate operator precedence from evaluation order, read C++17's tightened sequencing guarantees, and avoid unsequenced undefined behavior. - [Constant Expressions: constexpr, consteval & constinit](https://cppatlas.com/topics/constant-expressions) — [Markdown](https://cppatlas.com/api/notebook/topic/constant-expressions): Distinguish core constant expressions from constant-evaluated contexts, choose cleanly between constexpr, consteval, and constinit, and branch safely with if consteval. - [Lambdas: Closure Types, Captures & Generic Parameters](https://cppatlas.com/topics/lambdas) — [Markdown](https://cppatlas.com/api/notebook/topic/lambdas): Read every lambda as the compiler lowers it: a unique unnamed closure struct, captured data members, const-by-default operator(), and C++20/23 template and explicit-this extensions. - [Overload Resolution: Candidates, Viability & Ranking](https://cppatlas.com/topics/overload-resolution) — [Markdown](https://cppatlas.com/api/notebook/topic/overload-resolution): Trace the three-phase pipeline the compiler runs on every overloaded call—candidate lookup, viability filtering, and conversion-sequence ranking—to predict exact winners and ambiguities. - [Operator overloading](https://cppatlas.com/topics/operator-overloading) — [Markdown](https://cppatlas.com/api/notebook/topic/operator-overloading): An overloaded operator is an ordinary function with a special name that an operator expression calls. Arity, precedence and associativity never change, but evaluation guarantees can, and a few operators must be members. - [Three-way comparison](https://cppatlas.com/topics/three-way-comparison) — [Markdown](https://cppatlas.com/api/notebook/topic/three-way-comparison): C++20 lets one operator<=> answer less, equal or greater, and lets the compiler rewrite the other relational operators in terms of it. Equality stays separate, and the rewriting rules for == changed the meaning of some existing code. - [Function parameters and default arguments](https://cppatlas.com/topics/function-parameters-and-default-arguments) — [Markdown](https://cppatlas.com/api/notebook/topic/function-parameters-and-default-arguments): A function's type is built from its adjusted parameter types, so arrays become pointers and top-level const disappears, while default arguments stay outside the type and are bound to the declaration a call happens to see. - [Structured bindings](https://cppatlas.com/topics/structured-bindings) — [Markdown](https://cppatlas.com/api/notebook/topic/structured-bindings): A structured binding declaration creates one hidden variable from the initializer and then introduces names that refer into it. The specifiers you write apply to the hidden variable, and the names are aliases, not new variables. - [Member functions and this](https://cppatlas.com/topics/member-functions-and-this) — [Markdown](https://cppatlas.com/api/notebook/topic/member-functions-and-this): A non-static member function is an ordinary function with one extra parameter, the object it is called on. Qualifiers, overloading, `this` and C++23's explicit object parameters all follow from taking that parameter seriously. - [Constructors & Member Initialization Order](https://cppatlas.com/topics/constructors-and-initialization-order) — [Markdown](https://cppatlas.com/api/notebook/topic/constructors-and-initialization-order): Follow the deterministic sequence of base-class, member, and destructor execution—and avoid initializer reordering traps, virtual dispatch bugs, and accidental non-aggregates. - [Inheritance and Virtual Functions](https://cppatlas.com/topics/inheritance-and-virtual-functions) — [Markdown](https://cppatlas.com/api/notebook/topic/inheritance-and-virtual-functions): How C++ lays out base subobjects, dispatches virtual calls through vtables, handles multiple and virtual inheritance, and traps callers during construction and destruction. - [Multiple and virtual inheritance](https://cppatlas.com/topics/multiple-and-virtual-inheritance) — [Markdown](https://cppatlas.com/api/notebook/topic/multiple-and-virtual-inheritance): With several bases, a derived object holds several base subobjects at different addresses, so conversions may move the pointer and names may be ambiguous. Virtual inheritance shares one base subobject among all paths, at the price of most-derived initialization and run-time located bases. - [Access control and friends](https://cppatlas.com/topics/access-control-and-friends) — [Markdown](https://cppatlas.com/api/notebook/topic/access-control-and-friends): Access control decides whether a name may be used, never which entity a name means. It is checked after lookup and overload resolution, it follows the static type, and friendship grants it one class or function at a time. - [Conversion functions and explicit](https://cppatlas.com/topics/conversion-functions-and-explicit) — [Markdown](https://cppatlas.com/api/notebook/topic/conversion-functions-and-explicit): A class can convert from other types through converting constructors and to other types through conversion functions. The language applies at most one of these implicitly, and `explicit` removes a conversion from the implicit contexts without removing it from direct initialization. - [Pointers to members](https://cppatlas.com/topics/pointers-to-members) — [Markdown](https://cppatlas.com/api/notebook/topic/pointers-to-members): A pointer to member names a member of a class without naming an object, and is applied to an object later with `.*` or `->*`. It converts along the inheritance hierarchy in the opposite direction from object pointers, and `std::invoke` turns it into an ordinary callable. - [RAII and Resource Management](https://cppatlas.com/topics/raii-and-resource-management) — [Markdown](https://cppatlas.com/api/notebook/topic/raii-and-resource-management): Bind every resource invariant to an object lifetime so deterministic destructors, stack unwinding, and the Rule of Zero eliminate leaks by construction. - [Template instantiation and specialization](https://cppatlas.com/topics/template-instantiation-and-specialization) — [Markdown](https://cppatlas.com/api/notebook/topic/template-instantiation-and-specialization): A template is a recipe, and a specialization is what you get for one set of arguments, either cooked by the compiler on demand or written by you in advance. Knowing when the compiler cooks, and what your hand-written versions replace, explains lazy members, extern template and the classic function-specialization surprise. - [Template argument deduction](https://cppatlas.com/topics/template-argument-deduction) — [Markdown](https://cppatlas.com/api/notebook/topic/template-argument-deduction): Deduction matches each function parameter type against the type of its argument, independently, and then insists the answers agree. A handful of adjustments, a list of contexts that deduce nothing, and the rule that deduction never considers conversions explain almost every surprising call. - [Dependent names and two-phase lookup](https://cppatlas.com/topics/dependent-names-and-two-phase-lookup) — [Markdown](https://cppatlas.com/api/notebook/topic/dependent-names-and-two-phase-lookup): A template is checked twice, once when it is defined and once for each set of arguments. Names that do not depend on the template parameters are bound at the definition, dependent names wait for instantiation, and the parser needs `typename` and `template` to read dependent code before it knows what the names mean. - [Variadic templates and fold expressions](https://cppatlas.com/topics/variadic-templates-and-fold-expressions) — [Markdown](https://cppatlas.com/api/notebook/topic/variadic-templates-and-fold-expressions): A parameter pack stands for zero or more template or function arguments, and the only thing you can do with one is expand it, repeating a pattern once per element. C++17 fold expressions reduce a pack with an operator, replacing most of the recursion that C++11 variadic code needed. - [SFINAE and Concepts](https://cppatlas.com/topics/sfinae-and-concepts) — [Markdown](https://cppatlas.com/api/notebook/topic/sfinae-and-concepts): Trace how substitution failures prune candidates silently during C++17 template deduction, and how C++20 concepts replace enable_if with named atomic constraints and subsumption. - [SFINAE](https://cppatlas.com/topics/sfinae) — [Markdown](https://cppatlas.com/api/notebook/topic/sfinae): When substituting template arguments into a function template's declaration produces an invalid type or expression, that template quietly leaves the overload set. Only failures in the immediate context of the signature count; everything else is a hard error. - [Concepts and constraints](https://cppatlas.com/topics/concepts-and-constraints) — [Markdown](https://cppatlas.com/api/notebook/topic/concepts-and-constraints): A concept is a named compile-time predicate on template arguments, and a constraint is a predicate a template must satisfy before it can be used. The compiler breaks constraints into atomic pieces, and that decomposition, not the meaning of the expressions, decides which overload is more constrained. - [Forwarding References and Perfect Forwarding](https://cppatlas.com/topics/forwarding-references-and-perfect-forwarding) — [Markdown](https://cppatlas.com/api/notebook/topic/forwarding-references-and-perfect-forwarding): Decode the T&& template deduction exception, reference collapsing rules, and why std::forward and C++23 std::forward_like preserve exact value category and constness. - [Class template argument deduction](https://cppatlas.com/topics/class-template-argument-deduction) — [Markdown](https://cppatlas.com/api/notebook/topic/class-template-argument-deduction): Since C++17 you can name a class template without arguments and let the initializer decide them. The compiler turns every constructor and deduction guide into a fictional function template, runs overload resolution against them, and uses the winner's return type; the surprises come from which fictional function wins. - [Type traits and metaprogramming](https://cppatlas.com/topics/type-traits-and-metaprogramming) — [Markdown](https://cppatlas.com/api/notebook/topic/type-traits-and-metaprogramming): A type trait is a class template that maps types to a constant or to another type, answered either by specialization or by the compiler itself. Knowing exactly which question each trait asks, and when its operands are instantiated, separates working metaprograms from subtly wrong ones. - [CRTP and Deducing This](https://cppatlas.com/topics/crtp-and-deducing-this) — [Markdown](https://cppatlas.com/api/notebook/topic/crtp-and-deducing-this): Achieve zero-overhead static polymorphism with the Curiously Recurring Template Pattern, then eliminate its boilerplate and fourfold member overloads using C++23 explicit object parameters. - [Non-type template parameters](https://cppatlas.com/topics/non-type-template-parameters) — [Markdown](https://cppatlas.com/api/notebook/topic/non-type-template-parameters): A non-type template parameter makes a compile-time value part of a type's identity. Which types may carry such values, which arguments are acceptable, and when two arguments name the same specialization all follow from one requirement, that the compiler must be able to decide template-argument equivalence. - [Partial ordering of templates](https://cppatlas.com/topics/partial-ordering-of-templates) — [Markdown](https://cppatlas.com/api/notebook/topic/partial-ordering-of-templates): When several function templates or class template partial specializations match equally well, the compiler picks the most specialized one by deducing each template against a synthesized instance of the other. Constraints, forwarding references, packs and C++20 rewritten operators each add a rule on top, and some pairs stay ambiguous no matter what. - [Exceptions and stack unwinding](https://cppatlas.com/topics/exceptions-and-stack-unwinding) — [Markdown](https://cppatlas.com/api/notebook/topic/exceptions-and-stack-unwinding): A throw creates an exception object in special storage, searches outward for the first handler whose type matches under a short list of rules, and destroys every automatic object on the way. When no handler matches, std::terminate runs, and whether anything was unwound first is up to the implementation. - [noexcept](https://cppatlas.com/topics/noexcept) — [Markdown](https://cppatlas.com/api/notebook/topic/noexcept): The noexcept specifier is a promise that a function will not let an exception escape, enforced at run time by std::terminate rather than at compile time. The noexcept operator asks whether an expression could throw, and since C++17 the promise is part of the function type. - [Exception-safety guarantees](https://cppatlas.com/topics/exception-safety-guarantees) — [Markdown](https://cppatlas.com/api/notebook/topic/exception-safety-guarantees): How stack unwinding interacts with class invariants: the Abrahams guarantees, noexcept move optimization, copy-and-swap, and unwinding traps. - [Optional, expected, and error codes](https://cppatlas.com/topics/optional-expected-and-error-codes) — [Markdown](https://cppatlas.com/api/notebook/topic/optional-expected-and-error-codes): Choosing value-based error channels in modern C++: std::optional, C++23 std::expected, monadic combinators, and std::error_code vs std::error_condition. - [Object lifetime and storage](https://cppatlas.com/topics/object-lifetime-and-storage) — [Markdown](https://cppatlas.com/api/notebook/topic/object-lifetime-and-storage): Why raw memory allocation differs from object existence: storage durations, [basic.life] rules, implicit-lifetime types, std::launder, and temporary lifetime extension. - [Object layout and alignment](https://cppatlas.com/topics/object-layout-and-alignment) — [Markdown](https://cppatlas.com/api/notebook/topic/object-layout-and-alignment): What the standard actually promises about sizeof, alignof, member order and padding, which class properties unlock byte-level tricks, and where the standard stops and the ABI takes over. - [Strict aliasing and undefined behavior](https://cppatlas.com/topics/strict-aliasing-and-ub) — [Markdown](https://cppatlas.com/api/notebook/topic/strict-aliasing-and-ub): Why the optimizer relies on type-based alias analysis, what [basic.lval] permits, why union punning fails in C++, and how std::bit_cast replaces pointer casts. - [Strict aliasing and undefined behavior](https://cppatlas.com/topics/strict-aliasing-and-undefined-behavior) — [Markdown](https://cppatlas.com/api/notebook/topic/strict-aliasing-and-undefined-behavior): Undefined behavior is a promise you make to the optimizer, not a crash you might get. This page covers the kinds of non-portable behavior, the type-accessibility rule behind strict aliasing, the sanctioned ways to reinterpret bytes, and the pointer rules that compilers quietly rely on. - [Atomics and memory ordering](https://cppatlas.com/topics/atomics-and-memory-ordering) — [Markdown](https://cppatlas.com/api/notebook/topic/atomics-and-memory-ordering): How C++ defines memory locations, data races, happens-before graphs, acquire-release synchronization, store buffering, and fences. - [Dynamic allocation with new and delete](https://cppatlas.com/topics/dynamic-allocation-new-and-delete) — [Markdown](https://cppatlas.com/api/notebook/topic/dynamic-allocation-new-and-delete): A new-expression is two steps, a call to an allocation function and then initialization, and a delete-expression is the same two steps in reverse. This page follows both steps through exceptions, arrays, placement forms, replacement, class-specific operators and the mismatches that are undefined. - [Smart pointers, control blocks, and allocators](https://cppatlas.com/topics/smart-pointers-and-allocators) — [Markdown](https://cppatlas.com/api/notebook/topic/smart-pointers-and-allocators): How unique_ptr achieves zero-overhead ownership, what a shared_ptr control block stores, and how allocator_traits and std::pmr decouple allocation strategy from container types. - [Smart pointers](https://cppatlas.com/topics/smart-pointers) — [Markdown](https://cppatlas.com/api/notebook/topic/smart-pointers): unique_ptr makes single ownership a property of the type at no run-time cost, shared_ptr counts owners in a separate control block, and weak_ptr observes without owning. This page covers what each one stores, where the deleter lives, which operations are thread-safe, and the bugs that come from owning one object twice. - [Allocators and polymorphic memory resources](https://cppatlas.com/topics/allocators-and-pmr) — [Markdown](https://cppatlas.com/api/notebook/topic/allocators-and-pmr): An allocator tells a container where its memory comes from, and allocator_traits fills in everything the allocator leaves out. This page covers the minimal allocator, rebinding, the propagation traits that decide what copy, move and swap do with allocator state, and the std::pmr design that puts the memory source behind a virtual interface. - [Pointers, arrays and pointer arithmetic](https://cppatlas.com/topics/pointers-arrays-and-pointer-arithmetic) — [Markdown](https://cppatlas.com/api/notebook/topic/pointers-arrays-and-pointer-arithmetic): A pointer value is not just an address; it points to an object, past the end of one, nowhere, or it is invalid. This page covers array-to-pointer decay and where it stops, what arithmetic and comparison the standard defines, multidimensional arrays, function pointers, nullptr, references and std::to_address. - [Threads, jthread, cooperative stop, and locks](https://cppatlas.com/topics/threads-jthread-and-locks) — [Markdown](https://cppatlas.com/api/notebook/topic/threads-jthread-and-locks): Why raw std::thread terminates on destruction, how std::jthread and stop_token provide cooperative cancellation, and how RAII locks, condition variables, latches, barriers, and semaphores coordinate concurrent execution. - [Threads and jthread](https://cppatlas.com/topics/threads-and-jthread) — [Markdown](https://cppatlas.com/api/notebook/topic/threads-and-jthread): A std::thread is an owning handle that you must join or detach before it dies, and it copies its arguments before the new thread starts. C++20's std::jthread joins for you and adds cooperative cancellation through stop tokens. - [Mutexes and locks](https://cppatlas.com/topics/mutexes-and-locks) — [Markdown](https://cppatlas.com/api/notebook/topic/mutexes-and-locks): A mutex turns a region of code into a critical section and creates happens-before between whoever unlocks and whoever locks next. This page covers the mutex kinds, the RAII lock wrappers, deadlock and std::lock, the undefined behavior that is easy to write, and one-time initialization. - [Condition variables and waiting](https://cppatlas.com/topics/condition-variables-and-waiting) — [Markdown](https://cppatlas.com/api/notebook/topic/condition-variables-and-waiting): A condition variable lets a thread sleep until some state guarded by a mutex changes, and it is only correct when the waiter rechecks a predicate and the notifier changes that predicate under the mutex. C++20 adds atomic waits, semaphores, latches and barriers for the cases a condition variable handles clumsily. - [Futures, promises and async](https://cppatlas.com/topics/futures-promises-and-async) — [Markdown](https://cppatlas.com/api/notebook/topic/futures-promises-and-async): A future and its provider share one heap-allocated state that carries exactly one value or exception from one thread to another. This page covers promise, packaged_task and std::async, the launch-policy and destructor traps, the future_error cases, and why standard futures cannot be chained. - [C++20 coroutines and C++23 std::generator](https://cppatlas.com/topics/coroutines) — [Markdown](https://cppatlas.com/api/notebook/topic/coroutines): How C++20 stackless coroutines compile into resumable state-machine frames, how promise_type, awaitables, and symmetric transfer govern suspension, and how C++23 std::generator and lifetime rules keep async code sound. - [Coroutine library and generators](https://cppatlas.com/topics/coroutine-library-and-generators) — [Markdown](https://cppatlas.com/api/notebook/topic/coroutine-library-and-generators): The header gives you a raw, non-owning handle to a coroutine frame and two trivial awaiters, and everything else is yours to build. This page builds a minimal generator and a minimal task on top of those pieces, then shows what C++23's std::generator does for you and where its lifetimes still bite. - [Lock-free programming and ABA](https://cppatlas.com/topics/lock-free-programming-and-aba) — [Markdown](https://cppatlas.com/api/notebook/topic/lock-free-programming-and-aba): Lock-free code replaces mutual exclusion with compare-and-swap retry loops, which buys a progress guarantee and costs you memory reclamation. This page builds the Treiber stack, shows how the ABA problem and use-after-free break it, and surveys tagged pointers, hazard pointers, RCU and atomic shared_ptr as fixes. - [Parallel algorithms and execution policies](https://cppatlas.com/topics/parallel-algorithms-and-execution-policies) — [Markdown](https://cppatlas.com/api/notebook/topic/parallel-algorithms-and-execution-policies): Passing an execution policy to a standard algorithm grants the library permission to run your callbacks on several threads, interleaved within one thread, or both. This page explains what each policy permits, what that forbids in your code, why reduce is not accumulate, and what actually runs in parallel with GCC and Clang today. - [Containers, memory layouts, and iterator invalidation](https://cppatlas.com/topics/containers-and-iterator-invalidation) — [Markdown](https://cppatlas.com/api/notebook/topic/containers-and-iterator-invalidation): How physical memory layouts dictate pointer, reference, and iterator invalidation across vector, deque, list, node-based maps, unordered hash tables, and C++23 flat_map. - [Sequence containers](https://cppatlas.com/topics/sequence-containers) — [Markdown](https://cppatlas.com/api/notebook/topic/sequence-containers): vector, deque, list, forward_list and array differ in one thing, where they put their elements, and every complexity bound, invalidation rule and exception guarantee follows from that layout. Learn the layouts and the rest can be derived. - [Associative and unordered containers](https://cppatlas.com/topics/associative-and-unordered-containers) — [Markdown](https://cppatlas.com/api/notebook/topic/associative-and-unordered-containers): The ordered containers are sorted trees driven by a comparator, and the unordered ones are hash tables driven by a hash and an equality predicate. The rules for keys, complexity, rehashing and the many insertion functions all follow from those two designs. - [Iterator invalidation](https://cppatlas.com/topics/iterator-invalidation) — [Markdown](https://cppatlas.com/api/notebook/topic/iterator-invalidation): An iterator is a handle into a container's storage, and an operation invalidates it exactly when that storage or the machinery for finding it changes. Learn each container's layout and the invalidation rules can be derived rather than memorized. - [Container adaptors and flat containers](https://cppatlas.com/topics/container-adaptors-and-flat-containers) — [Markdown](https://cppatlas.com/api/notebook/topic/container-adaptors-and-flat-containers): stack, queue and priority_queue restrict a real container to a narrow interface, and the C++23 flat_map and flat_set family turns sorted vectors into associative containers. Both trade a wide interface for a layout you can reason about, and both have sharp edges. - [Strings, string_view, and span](https://cppatlas.com/topics/strings-views-and-spans) — [Markdown](https://cppatlas.com/api/notebook/topic/strings-views-and-spans): How std::string owns characters with Small String Optimization while std::string_view and std::span borrow contiguous memory safely without hidden allocations. - [Strings and string_view](https://cppatlas.com/topics/strings-and-string-view) — [Markdown](https://cppatlas.com/api/notebook/topic/strings-and-string-view): std::string owns a contiguous, always null-terminated buffer and invalidates like a vector. std::string_view is a non-owning pointer and length pair, not null-terminated, whose main hazard is outliving the thing it looks at. - [span and mdspan](https://cppatlas.com/topics/span-and-mdspan) — [Markdown](https://cppatlas.com/api/notebook/topic/span-and-mdspan): std::span is a non-owning pointer and length over contiguous elements, with the extent optionally fixed in the type. std::mdspan (C++23) extends the same borrowed view to several dimensions, with a layout policy for indexing and an accessor policy for element access. - [Node handles and heterogeneous lookup](https://cppatlas.com/topics/node-handles-and-heterogeneous-lookup) — [Markdown](https://cppatlas.com/api/notebook/topic/node-handles-and-heterogeneous-lookup): Node handles (C++17) let you take a node out of a map or set, change its key or move its value, and put it back or into another container without copying or allocating. Heterogeneous lookup (C++14 ordered, C++20 unordered) lets you search by a type other than the key, so no temporary key has to be built. - [array, bitset and vector](https://cppatlas.com/topics/array-bitset-and-vector-bool) — [Markdown](https://cppatlas.com/api/notebook/topic/array-bitset-and-vector-bool): std::array is a plain aggregate wrapping a C array, std::bitset is a fixed-size bit set with a proxy for single bits, and vector is a packed specialization whose proxy references make it behave unlike every other vector. - [Iterator categories and concepts](https://cppatlas.com/topics/iterator-categories-and-concepts) — [Markdown](https://cppatlas.com/api/notebook/topic/iterator-categories-and-concepts): C++ has two iterator taxonomies, the legacy named requirements from C++98 and the C++20 iterator concepts, and an iterator can sit at different levels in each. Knowing which one an algorithm consults explains why proxy iterators are random-access in one world and input-only in the other. - [The algorithm library](https://cppatlas.com/topics/algorithms) — [Markdown](https://cppatlas.com/api/notebook/topic/algorithms): Standard algorithms work on iterator ranges, not containers, and every requirement they state about iterators, callables and sortedness is a precondition you must meet. The ranges versions add projections, sentinels and richer return types, but keep the same contracts. - [Ranges, views, and niebloids](https://cppatlas.com/topics/ranges-views-and-niebloids) — [Markdown](https://cppatlas.com/api/notebook/topic/ranges-views-and-niebloids): How C++20 ranges decouple sentinels from iterators, compose lazy views, prevent dangling iterators with borrowed_range, and suppress ADL with niebloids. - [Ranges and views](https://cppatlas.com/topics/ranges-and-views) — [Markdown](https://cppatlas.com/api/notebook/topic/ranges-and-views): A range is anything you can call ranges::begin and ranges::end on; a view is a range cheap enough to pass by value and compose lazily. Views compute on demand, may cache, and refer to data they usually do not own, which explains both their power and their sharp edges. - [Borrowed ranges and dangling](https://cppatlas.com/topics/borrowed-ranges-and-dangling) — [Markdown](https://cppatlas.com/api/notebook/topic/borrowed-ranges-and-dangling): An iterator is only valid while the thing it points into is alive. Borrowed ranges are the ranges whose iterators survive the range object, and the ranges library uses that property to turn many dangling iterators into compile errors, but views, pipelines and range-based for loops still leave plenty of ways to dangle. - [Range adaptors and pipelines](https://cppatlas.com/topics/range-adaptors-and-pipelines) — [Markdown](https://cppatlas.com/api/notebook/topic/range-adaptors-and-pipelines): A range adaptor turns one view into another lazily, and the pipe operator only rearranges the call. What each adaptor keeps of its input's iterator category, and what it caches, decides where a pipeline compiles, how often your functions run, and when it quietly misbehaves. - [Strict weak ordering and comparators](https://cppatlas.com/topics/strict-weak-ordering-and-comparators) — [Markdown](https://cppatlas.com/api/notebook/topic/strict-weak-ordering-and-comparators): Every sorting algorithm and ordered container assumes its comparator is a strict weak ordering, and a comparator that is not one gives undefined behavior rather than a merely odd order. Knowing the four laws, and the equivalence they define, explains which comparators are safe and why ordered lookup ignores operator==. - [Customization points and niebloids](https://cppatlas.com/topics/customization-points-and-niebloids) — [Markdown](https://cppatlas.com/api/notebook/topic/customization-points-and-niebloids): Generic code needs a way to call "the right swap" or "the right begin" for a type it has never seen. C++ moved from the ADL two-step to customization point objects and niebloids, function objects that do the lookup for you and cannot be hijacked by it, and settled on hidden friends as the way for types to plug in. - [Iterator adaptors and sentinels](https://cppatlas.com/topics/iterator-adaptors-and-sentinels) — [Markdown](https://cppatlas.com/api/notebook/topic/iterator-adaptors-and-sentinels): Iterator adaptors wrap an iterator to change what moving or dereferencing means, and C++20 sentinels let the end of a range be a different type from its iterator. Together they explain reverse_iterator's off-by-one base, counted and common iterators, subrange, and why C++23 had to fix cbegin. - [Vocabulary types and std::format](https://cppatlas.com/topics/vocabulary-types-and-format) — [Markdown](https://cppatlas.com/api/notebook/topic/vocabulary-types-and-format): Value-semantic sum types, type-erased callables with const and move-only correctness, and compile-time checked text formatting in modern C++. - [optional, variant and any](https://cppatlas.com/topics/optional-variant-any) — [Markdown](https://cppatlas.com/api/notebook/topic/optional-variant-any): Three vocabulary types answer three different questions. optional is a value or nothing, variant is exactly one of a closed list, and any is one of an open set, checked at run time. Each has a precise rule for how it can be wrong, and those rules are the part worth knowing. - [pair, tuple and the tuple protocol](https://cppatlas.com/topics/tuple-and-pair) — [Markdown](https://cppatlas.com/api/notebook/topic/tuple-and-pair): A tuple is a struct whose members have numbers instead of names. The interesting parts are how it is built, how tuples of references work as a multiple-assignment device, and how the tuple protocol lets any type take part in structured bindings and in tuple algorithms. - [Callable wrappers](https://cppatlas.com/topics/callable-wrappers) — [Markdown](https://cppatlas.com/api/notebook/topic/callable-wrappers): std::function, move_only_function, copyable_function and function_ref are four answers to the question of how to store or pass a callable of unknown type. They differ in ownership, copyability and in whether the call signature can say const, noexcept or a reference qualifier. The invoke rules and the binders sit underneath all of them. - [chrono](https://cppatlas.com/topics/chrono) — [Markdown](https://cppatlas.com/api/notebook/topic/chrono): std::chrono puts the unit into the type. A duration is a count and a ratio, a time point is a duration since a clock's epoch, and a clock says where time points come from. The rules that matter are which conversions are implicit, what each clock promises, and how C++20 calendars and time zones handle dates that do not exist. - [std::format and std::print](https://cppatlas.com/topics/format-and-print) — [Markdown](https://cppatlas.com/api/notebook/topic/format-and-print): std::format replaces printf and iostream formatting with a type-safe format string that is checked at compile time and extended through formatter specializations. C++23 adds range and tuple formatting and std::print, which writes directly to a stream with Unicode awareness. - [Iostreams](https://cppatlas.com/topics/iostreams) — [Markdown](https://cppatlas.com/api/notebook/topic/iostreams): An iostream is a formatting layer on top of a buffer layer, with a state word that records what went wrong. Most iostream bugs come from reading the state bits wrong, from sticky formatting, or from mixing the formatted and unformatted halves of the interface. - [std::filesystem](https://cppatlas.com/topics/filesystem) — [Markdown](https://cppatlas.com/api/notebook/topic/filesystem): A path is a value that names a location, not a handle to a file, and most of its member functions are pure text manipulation. The rest of the library asks the operating system questions whose answers can change at any moment, which is why every operation comes in a throwing and a non-throwing form and why check-then-act code is wrong. - [Random numbers](https://cppatlas.com/topics/random-numbers) — [Markdown](https://cppatlas.com/api/notebook/topic/random-numbers): The random library splits randomness into engines that produce raw bits, distributions that shape them into values, and a seed that decides where an engine starts. Each of those parts has traps, from modulo bias and weak seeding to distributions whose output differs between standard libraries. - [Floating point and numerics](https://cppatlas.com/topics/floating-point-and-numerics) — [Markdown](https://cppatlas.com/api/notebook/topic/floating-point-and-numerics): The standard says very little about how floating point behaves, so IEEE 754 behaviour is something you check for, not something you get. This topic covers NaN and signed zero, conversions that are undefined, excess precision, and the library tools that behave well. - [Bit manipulation](https://cppatlas.com/topics/bit-manipulation) — [Markdown](https://cppatlas.com/api/notebook/topic/bit-manipulation): C++20 gave bits a real library in the header bit, and it also pinned down shifts on signed numbers. The traps that remain are shift counts, integer promotion on small types, and the preconditions of a few functions. - [Character types and Unicode](https://cppatlas.com/topics/character-types-and-unicode) — [Markdown](https://cppatlas.com/api/notebook/topic/character-types-and-unicode): C++ has six character types and four literal prefixes, but only the library's code-unit view of text. Knowing what a char holds, which encoding a literal gets, and what counts as a character for the reader is what keeps Unicode code correct. - [Integer arithmetic and overflow](https://cppatlas.com/topics/integer-arithmetic-and-overflow) — [Markdown](https://cppatlas.com/api/notebook/topic/integer-arithmetic-and-overflow): Unsigned integers wrap around, signed integers do not get to overflow at all, and promotion quietly turns narrow unsigned arithmetic into signed arithmetic. This topic covers the division rules, safe comparison, narrowing, and the newer saturating and checked operations. - [C++26: Contracts, Reflection, Execution, and Erroneous Behavior](https://cppatlas.com/topics/cpp26-contracts-reflection-execution) — [Markdown](https://cppatlas.com/api/notebook/topic/cpp26-contracts-reflection-execution): How C++26 replaces fragile workarounds with language-level contracts (P2900), value-based static reflection (P2996), std::execution senders (P2300), and erroneous behavior (P2795). - [Contracts](https://cppatlas.com/topics/contracts) — [Markdown](https://cppatlas.com/api/notebook/topic/contracts): C++26 adds preconditions, postconditions and contract_assert. A contract assertion is a redundant check whose evaluation semantic, from ignore to quick-enforce, is chosen by the implementation rather than written in the code. - [Static reflection](https://cppatlas.com/topics/reflection) — [Markdown](https://cppatlas.com/api/notebook/topic/reflection): C++26 lets a program ask the compiler about its own declarations at compile time. The `^^` operator turns a construct into a `std::meta::info` value, `` functions query and transform those values, and a splice `[: r :]` turns a value back into code. - [Senders and receivers (std::execution)](https://cppatlas.com/topics/senders-and-receivers) — [Markdown](https://cppatlas.com/api/notebook/topic/senders-and-receivers): C++26's std::execution describes asynchronous work as lazy sender values that complete on exactly one of three channels: value, error, or stopped. Algorithms compose senders, schedulers say where work runs, and nothing happens until a sender is connected to a receiver and started. - [std::simd data-parallel types](https://cppatlas.com/topics/simd-data-parallel-types) — [Markdown](https://cppatlas.com/api/notebook/topic/simd-data-parallel-types): C++26 adds std::simd::vec and std::simd::mask, portable types that hold a fixed number of elements and apply every operation to all of them at once, so that ordinary-looking C++ compiles to SIMD instructions. The rules for implicit conversions, masks, and loads are what make the code portable. - [Erroneous behaviour and C++26 language changes](https://cppatlas.com/topics/erroneous-behaviour-and-cpp26-language-changes) — [Markdown](https://cppatlas.com/api/notebook/topic/erroneous-behaviour-and-cpp26-language-changes): C++26 adds erroneous behaviour, a new category for code that is wrong but still well-defined, and uses it to take uninitialized reads out of undefined behaviour. Alongside it come several rules that turn old traps into compile errors, plus the small conveniences `_`, `= delete("why")`, computed `static_assert` messages, and `#embed`. - [Pack indexing and C++26 template features](https://cppatlas.com/topics/pack-indexing-and-cpp26-templates) — [Markdown](https://cppatlas.com/api/notebook/topic/pack-indexing-and-cpp26-templates): C++26 lets you subscript a pack, turn a structured binding into a pack, befriend a whole pack, order constraints written as folds, and pass concepts and variable templates as template arguments. Each feature removes a recursive or helper-template workaround. - [inplace_vector and the new C++26 containers](https://cppatlas.com/topics/inplace-vector-and-new-containers) — [Markdown](https://cppatlas.com/api/notebook/topic/inplace-vector-and-new-containers): C++26 adds inplace_vector, a vector whose capacity is fixed and whose elements live inside the object; hive, a block-based container with stable addresses; and indirect and polymorphic, which give heap-allocated objects value semantics. optional becomes a range and gains a reference specialization, and span gets at(). - [Hazard pointers and RCU](https://cppatlas.com/topics/hazard-pointers-and-rcu) — [Markdown](https://cppatlas.com/api/notebook/topic/hazard-pointers-and-rcu): C++26 adds two standard answers to the question of when a lock-free reader's object may be deleted. Hazard pointers protect individual objects and bound the garbage; RCU protects whole read-side regions and makes readers nearly free. - [constexpr in C++26](https://cppatlas.com/topics/constexpr-in-cpp26) — [Markdown](https://cppatlas.com/api/notebook/topic/constexpr-in-cpp26): C++26 lets constant evaluation cast from void*, use placement new, throw and catch exceptions, bind constexpr structured bindings and construct classes with virtual bases. The rule underneath stays the same, though, because nothing may leak out of the evaluation. ## Flagship Interactive Study Companions - [Value Semantics & C++17 Value Categories](https://cppatlas.com/w/cpp/language/value_category) — [Markdown](https://cppatlas.com/api/notebook/cpp/language/value_category): A prvalue in C++17+ is not an object in memory—it is an unmaterialized recipe to initialize a target slot. - [The C++ Memory Model, Happens-Before & Atomics](https://cppatlas.com/w/cpp/language/memory_model) — [Markdown](https://cppatlas.com/api/notebook/cpp/language/memory_model): Release/acquire does not flush CPU caches—it builds a happens-before bridge so ordinary writes before release become visible after acquire. - [Object Lifetime, Storage Duration & RAII](https://cppatlas.com/w/cpp/language/lifetime) — [Markdown](https://cppatlas.com/api/notebook/cpp/language/lifetime): Allocating bytes does not create an object, and freeing bytes is not what destroys one—lifetime begins at initialization and ends at destruction or storage reuse. - [Move Semantics, Forwarding References & Reference Collapsing](https://cppatlas.com/w/cpp/utility/move) — [Markdown](https://cppatlas.com/api/notebook/cpp/utility/move): T&& is a forwarding reference ONLY when T is a deduced template parameter of that exact function—not std::vector&&. - [C++20 Concepts, Subsumption & Overload Resolution](https://cppatlas.com/w/cpp/language/constraints) — [Markdown](https://cppatlas.com/api/notebook/cpp/language/constraints): Only named concepts participate in atomic constraint subsumption—writing identical raw requires expressions twice produces two distinct atoms and an ambiguous overload! ## C++ Reference Domains (/w/cpp) - Algorithms (194 pages): https://cppatlas.com/explore?lang=cpp&domain=Algorithms - atomic (85 pages): https://cppatlas.com/explore?lang=cpp&domain=atomic - Concepts (29 pages): https://cppatlas.com/explore?lang=cpp&domain=Concepts - Concurrency support (266 pages): https://cppatlas.com/explore?lang=cpp&domain=Concurrency%20support - Containers (791 pages): https://cppatlas.com/explore?lang=cpp&domain=Containers - Coroutine support (36 pages): https://cppatlas.com/explore?lang=cpp&domain=Coroutine%20support - Date and time utilities (331 pages): https://cppatlas.com/explore?lang=cpp&domain=Date%20and%20time%20utilities - Diagnostics (89 pages): https://cppatlas.com/explore?lang=cpp&domain=Diagnostics - Execution (19 pages): https://cppatlas.com/explore?lang=cpp&domain=Execution - Filesystem (130 pages): https://cppatlas.com/explore?lang=cpp&domain=Filesystem - Indexes (22 pages): https://cppatlas.com/explore?lang=cpp&domain=Indexes - Input/output (385 pages): https://cppatlas.com/explore?lang=cpp&domain=Input%2Foutput - Iterator (171 pages): https://cppatlas.com/explore?lang=cpp&domain=Iterator - Keywords (100 pages): https://cppatlas.com/explore?lang=cpp&domain=Keywords - Language (202 pages): https://cppatlas.com/explore?lang=cpp&domain=Language - Localization (152 pages): https://cppatlas.com/explore?lang=cpp&domain=Localization - Memory management (255 pages): https://cppatlas.com/explore?lang=cpp&domain=Memory%20management - Named Requirements (81 pages): https://cppatlas.com/explore?lang=cpp&domain=Named%20Requirements - Numerics (527 pages): https://cppatlas.com/explore?lang=cpp&domain=Numerics - Ranges (430 pages): https://cppatlas.com/explore?lang=cpp&domain=Ranges - Regular expressions (79 pages): https://cppatlas.com/explore?lang=cpp&domain=Regular%20expressions - Resources (2 pages): https://cppatlas.com/explore?lang=cpp&domain=Resources - Standard headers (141 pages): https://cppatlas.com/explore?lang=cpp&domain=Standard%20headers - Standard library (3 pages): https://cppatlas.com/explore?lang=cpp&domain=Standard%20library - Standards & support (17 pages): https://cppatlas.com/explore?lang=cpp&domain=Standards%20%26%20support - Strings (223 pages): https://cppatlas.com/explore?lang=cpp&domain=Strings - Technical specifications (637 pages): https://cppatlas.com/explore?lang=cpp&domain=Technical%20specifications - Text processing (13 pages): https://cppatlas.com/explore?lang=cpp&domain=Text%20processing - Type support (156 pages): https://cppatlas.com/explore?lang=cpp&domain=Type%20support - Utility (405 pages): https://cppatlas.com/explore?lang=cpp&domain=Utility ## C Reference Domains (/w/c) - Algorithms (3 pages): https://cppatlas.com/explore?lang=c&domain=Algorithms - Atomic operations (22 pages): https://cppatlas.com/explore?lang=c&domain=Atomic%20operations - Concurrency support (30 pages): https://cppatlas.com/explore?lang=c&domain=Concurrency%20support - Date and time utilities (18 pages): https://cppatlas.com/explore?lang=c&domain=Date%20and%20time%20utilities - Dynamic memory management (8 pages): https://cppatlas.com/explore?lang=c&domain=Dynamic%20memory%20management - Error handling (8 pages): https://cppatlas.com/explore?lang=c&domain=Error%20handling - File input/output (50 pages): https://cppatlas.com/explore?lang=c&domain=File%20input%2Foutput - Indexes (2 pages): https://cppatlas.com/explore?lang=c&domain=Indexes - Keywords (60 pages): https://cppatlas.com/explore?lang=c&domain=Keywords - Language (106 pages): https://cppatlas.com/explore?lang=c&domain=Language - Localization support (5 pages): https://cppatlas.com/explore?lang=c&domain=Localization%20support - Numerics (128 pages): https://cppatlas.com/explore?lang=c&domain=Numerics - Program support utilities (21 pages): https://cppatlas.com/explore?lang=c&domain=Program%20support%20utilities - Resources (2 pages): https://cppatlas.com/explore?lang=c&domain=Resources - Standard headers (1 pages): https://cppatlas.com/explore?lang=c&domain=Standard%20headers - Standards & support (9 pages): https://cppatlas.com/explore?lang=c&domain=Standards%20%26%20support - Strings (116 pages): https://cppatlas.com/explore?lang=c&domain=Strings - Technical specifications (9 pages): https://cppatlas.com/explore?lang=c&domain=Technical%20specifications - Type support (11 pages): https://cppatlas.com/explore?lang=c&domain=Type%20support - Utility (1 pages): https://cppatlas.com/explore?lang=c&domain=Utility - Variadic functions (6 pages): https://cppatlas.com/explore?lang=c&domain=Variadic%20functions ## Global Endpoints - Study Topics: https://cppatlas.com/topics - Concept Maps: https://cppatlas.com/maps - Study Desk: https://cppatlas.com/study - C++11–C++26 Evolution Timeline: https://cppatlas.com/standards - All Topics Markdown: https://cppatlas.com/api/notebook/topics-all - Unified Portal: https://cppatlas.com/w - Root C++ Reference: https://cppatlas.com/w/cpp - Root C Reference: https://cppatlas.com/w/c - Full Directory: https://cppatlas.com/explore - Standardese Quiz: https://cppatlas.com/quiz - Markdown & NotebookLM Studio: https://cppatlas.com/notebook - Full XML Sitemap (6713 URLs): https://cppatlas.com/sitemap.xml