Topics
115 topics in 13 tracks, each with a reading, a concept map and a quiz.
Not read yetRead
World map
Focused track: Program structure- Not read yet
- Read
- Debugger
- Next up
- Land route
- Sea crossing
115 topics in 13 tracks
Program structure
How source text becomes an executable: translation units, linkage, name lookup and modules.
- Translation Units, ODR, and Linkage8 minTrace 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 rule13 minEvery 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 ADL9 minTrace how the compiler maps an identifier to candidate declarations across unqualified lookup, qualified lookup, Argument-Dependent Lookup, and two-phase template lookup.
- Namespaces and scope12 minA 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 Modules9 minReplace fragile textual header graphs with semantic module interfaces, controlled exports, module linkage, and clean boundaries around legacy headers.
- The preprocessor and translation phases14 minBefore 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.
- Attributes12 minAttributes 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 termination14 minBefore 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.
Types and initialization
What a type promises, how values convert, and every spelling of initialization and deduction.
- Fundamental types and arithmetic conversions12 minThe 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 conversions13 minAn 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-qualifiers9 minWhat const and volatile actually guarantee, why multi-level pointer conversions restrict const, and how to pick the narrowest C++ cast without breaking strict aliasing.
- Casts13 minEach 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 qualifiers13 minA 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++9 minDecode default, value, zero, direct, copy, aggregate, and list initialization—and prevent the narrowing, most-vexing-parse, and initializer_list traps.
- Aggregates and designated initializers12 minAn 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 CTAD9 minMaster template-style auto deduction, the braced-initializer exception, decltype's two-rule split, structured bindings, and Class Template Argument Deduction.
- Enumerations and unions12 minAn 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 semantics
What an expression means, when resources move, and when copies disappear at the language level.
- Value categories9 minReplace 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 semantics10 minHow 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 NRVO9 minWhy 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 temporaries10 minWhich 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.
Expressions and functions
Evaluation order guarantees, compile-time execution, closure types and overload resolution.
- Evaluation Order, Sequencing & Undefined Side Effects7 minSeparate operator precedence from evaluation order, read C++17's tightened sequencing guarantees, and avoid unsequenced undefined behavior.
- Constant Expressions: constexpr, consteval & constinit8 minDistinguish 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 Parameters8 minRead 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 & Ranking9 minTrace 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 overloading12 minAn 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 comparison13 minC++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 arguments12 minA 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 bindings12 minA 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.
Classes
Subobject construction order, dynamic dispatch machinery and deterministic RAII.
- Member functions and this12 minA 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 Order8 minFollow 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 Functions9 minHow 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 inheritance13 minWith 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 friends12 minAccess 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 explicit12 minA 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 members11 minA 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 Management9 minBind every resource invariant to an object lifetime so deterministic destructors, stack unwinding, and the Rule of Zero eliminate leaks by construction.
Templates
Forwarding references, SFINAE, C++20 concept subsumption and C++23 explicit object parameters.
- Template instantiation and specialization12 minA 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 deduction12 minDeduction 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 lookup12 minA 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 expressions12 minA 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 Concepts10 minTrace 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.
- SFINAE12 minWhen 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 constraints13 minA 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 Forwarding9 minDecode 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 deduction13 minSince 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 metaprogramming13 minA 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 This9 minAchieve 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 parameters12 minA 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 templates13 minWhen 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 error handling
Stack unwinding, exception-safety guarantees and value-based error handling with expected.
- Exceptions and stack unwinding13 minA 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.
- noexcept12 minThe 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 guarantees10 minHow stack unwinding interacts with class invariants: the Abrahams guarantees, noexcept move optimization, copy-and-swap, and unwinding traps.
- Optional, expected, and error codes10 minChoosing value-based error channels in modern C++: std::optional, C++23 std::expected, monadic combinators, and std::error_code vs std::error_condition.
Memory model
Storage duration, object lifetime, strict aliasing, multi-core atomics and smart-pointer control blocks.
- Object lifetime and storage11 minWhy raw memory allocation differs from object existence: storage durations, [basic.life] rules, implicit-lifetime types, std::launder, and temporary lifetime extension.
- Object layout and alignment13 minWhat 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 behavior10 minWhy 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 behavior14 minUndefined 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 ordering11 minHow C++ defines memory locations, data races, happens-before graphs, acquire-release synchronization, store buffering, and fences.
- Dynamic allocation with new and delete14 minA 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 allocators9 minHow 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 pointers14 minunique_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 resources15 minAn 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 arithmetic14 minA 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.
Concurrency
Cooperative cancellation with jthread, synchronization primitives and C++20 coroutines.
- Threads, jthread, cooperative stop, and locks9 minWhy 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 jthread12 minA 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 locks13 minA 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 waiting14 minA 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 async13 minA 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::generator10 minHow 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 generators15 minThe <coroutine> 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 ABA15 minLock-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 policies14 minPassing 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 and strings
Memory layouts, iterator invalidation contracts, small-string optimization and non-owning views.
- Containers, memory layouts, and iterator invalidation9 minHow 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 containers12 minvector, 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 containers12 minThe 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 invalidation12 minAn 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 containers12 minstack, 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 span10 minHow 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_view12 minstd::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 mdspan12 minstd::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 lookup12 minNode 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<bool>12 minstd::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<bool> is a packed specialization whose proxy references make it behave unlike every other vector.
Iterators, algorithms and ranges
Iterator concepts, lazy range adaptors, borrowed ranges and customization point objects.
- Iterator categories and concepts14 minC++ 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 library15 minStandard 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 niebloids11 minHow C++20 ranges decouple sentinels from iterators, compose lazy views, prevent dangling iterators with borrowed_range, and suppress ADL with niebloids.
- Ranges and views14 minA 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 dangling13 minAn 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 pipelines13 minA 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 comparators12 minEvery 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 niebloids13 minGeneric 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 sentinels13 minIterator 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.
Library utilities
Type-safe unions, callable wrappers and compile-time checked formatting.
- Vocabulary types and std::format11 minValue-semantic sum types, type-erased callables with const and move-only correctness, and compile-time checked text formatting in modern C++.
- optional, variant and any14 minThree 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 protocol14 minA 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 wrappers15 minstd::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.
- chrono15 minstd::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::print13 minstd::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.
- Iostreams13 minAn 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::filesystem13 minA 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 numbers12 minThe 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 numerics13 minThe 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 manipulation13 minC++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 Unicode13 minC++ 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 overflow13 minUnsigned 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, static reflection, structured concurrency with std::execution and erroneous behavior.
- C++26: Contracts, Reflection, Execution, and Erroneous Behavior13 minHow C++26 replaces fragile workarounds with language-level contracts (P2900), value-based static reflection (P2996), std::execution senders (P2300), and erroneous behavior (P2795).
- Contracts14 minC++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 reflection15 minC++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, `<meta>` functions query and transform those values, and a splice `[: r :]` turns a value back into code.
- Senders and receivers (std::execution)16 minC++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 types14 minC++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 changes15 minC++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 features13 minC++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 containers14 minC++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 RCU13 minC++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++2613 minC++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.