Standard Library Reference

Wrapper classes that restrict and redefine the interface of sequence containers to model stacks, queues, and priority queues.

"Sequential containers and adaptors: deque for double-ended operations, list for stable iterators, queue/stack/priority_queue adaptors. Choose based on insertion pattern and iterator requirements."

Rules governing when container operations cause previously-obtained iterators, pointers, and references to become undefined to dereference.

Doubly-linked list container optimized for efficient insertion and removal at any position

Fixed-size contiguous array wrapper with value semantics, bounds checking, and full STL compatibility.

Double-ended queue supporting fast insertion and deletion at both ends with random access

C++23 sorted associative container adaptor storing key-value pairs contiguously, giving map semantics with cache-friendly sequential layout.

Sorted associative container adapters backed by contiguous storage — O(log n) binary search with cache-friendly memory layout, ideal for read-heavy workloads.

C++ std::forward_list for singly-linked storage with O(1) front insertion, minimal memory per node, forward-only iteration, and when to use it over std::list.

A C++26 sequence container providing O(1) insertion and erasure with stable iterators via a block-based, skipfield-backed memory layout.

std::map (sorted red-black tree, O(log n)) and std::unordered_map (hash table, O(1) avg): when to pick each, how to tune performance, and C++17/20/23 additions.

Ordered associative containers allowing duplicate keys — equal_range, node handles, erase semantics, and flat variants.

Ordered unique-element container backed by a red-black tree (set) and hash-table unique-element container (unordered_set) in C++.

"C++20 std::span: a zero-overhead view over contiguous data. Fixed vs dynamic extent, subspans, byte reinterpretation, and API design patterns."

C++ container adaptors — stack (LIFO), queue (FIFO), and priority_queue (heap-based) with underlying container selection, complexity, and practical patterns.

std::string — owning mutable character sequence with SSO, full modification API, searching, numeric conversions, and C++17/20/23 additions.

Hash map with O(1) average insert, lookup, and erase — the default associative container when key ordering is irrelevant.

Dynamic contiguous array container. Default choice for sequential collections. O(1) random access and amortized O(1) append. Reallocates when capacity exhausted.

Hash-based sets with O(1) average lookup—custom hashing, rehashing, iterator invalidation, C++17/20 additions, and performance traps.

std::binary_search, lower_bound, upper_bound, equal_range and partition_point: logarithmic search over sorted ranges, with ranges variants, comparators and pitfalls.

Reduce a range to a single value using std::accumulate, std::reduce, std::transform_reduce, and the C++23 ranges::fold family.

Algorithms for creating, maintaining, querying, and sorting heap-ordered ranges in-place using random-access iterators.

std::lexicographical_compare and its C++20 siblings: dictionary-order comparison of two ranges, custom comparators, parallel overloads, and three-way results.

Complete guide to std::min, std::max, std::minmax, clamp, and their range-element variants—signatures, version history, pitfalls, and idiomatic C++20 usage.

STL algorithms from <algorithm> that mutate a target range by copying, filling, generating, transforming, replacing, or rearranging elements.

C++ non-modifying algorithms — for_each, count, count_if, any_of, all_of, none_of, find, find_if, mismatch, equal, and their C++20 ranges equivalents.

Complete reference for C++ numeric algorithms: accumulate, reduce, transform_reduce, prefix scans, gcd, lcm, midpoint, lerp, and parallel variants.

C++17 execution policies for STL algorithms — par, par_unseq, reduce, transform_reduce, scan, thread safety, and platform requirements.

Reorder, inspect, and copy elements based on a predicate with std::partition and its companion algorithms.

Generate and enumerate lexicographic permutations, check range equivalence, and randomly shuffle sequences using the C++ Standard Library.

"C++20 ranges and views: range concepts, lazy view adaptors, composable pipelines, projections, and the pitfalls that bite experienced engineers."

Prefix-sum algorithms in <numeric>: partial_sum (C++98) and the parallel-capable inclusive_scan, exclusive_scan, and transform variants added in C++17.

C++ searching algorithms — std::find, binary_search, lower_bound, upper_bound, equal_range, search, and C++20 ranges equivalents with projections.

Set algorithms operating on sorted ranges and heap operations — multiset semantics, complexity guarantees, and C++20 ranges versions.

"C++ sorting: std::sort, std::stable_sort, std::partial_sort, std::nth_element, ranges variants, custom comparators, and strict weak ordering."

Merge two sorted ranges into a single sorted output range. Both std::merge and std::inplace_merge are stable and have been available since C++98.

Select n elements uniformly at random without replacement from a population range, preserving their relative order.

Complete guide to <algorithm> and std::ranges algorithms — sorting, searching, transforming, partitioning, and parallel execution.

Deep reference for std::transform, for_each, copy, fill, generate, remove, rotate, and C++20 ranges equivalents with pitfalls and best practices.

Low-level algorithms for constructing, copying, moving, and destroying objects in raw allocated storage, decoupling allocation from object lifetime management.

std::condition_variable — atomic wait/notify, spurious wakeup handling, timed waits, condition_variable_any, and C++20 stop_token integration.

C++ lock-free programming — compare_exchange, memory orders, Treiber stack, ABA problem, safe reclamation, and when to prefer mutexes.

Lock-free reader synchronization for read-heavy workloads — readers never block; writers retire old data after a guaranteed grace period.

C++20 counting_semaphore, binary_semaphore, latch, and barrier — efficient thread synchronization primitives with defined happens-before semantics.

"C++11 async primitives: std::async for task-based concurrency, future/promise as a one-shot cross-thread value channel, packaged_task for callable wrapping."

std::atomic<T> provides lock-free atomic operations with configurable memory ordering — covers memory orders, CAS loops, atomic_flag, atomic_ref, wait/notify, and fences.

Apply atomic operations to existing non-atomic objects with std::atomic_ref (C++20): syntax, alignment rules, specializations, and pitfalls.

Thread-safe one-time initialization in C++11 with std::call_once and std::once_flag, including exception semantics, lazy init patterns, and comparison with function-local statics.

P2300 Senders/Receivers: structured, composable async that decouples work from execution context — portable parallelism across thread pools, GPU queues, and event loops without callbacks.

"C++20 std::jthread: auto-joining thread with cooperative cancellation via stop_token, stop_source, and stop_callback."

Controls how memory accesses around atomic operations are ordered across threads; the backbone of C++'s lock-free concurrency model.

C++ mutual exclusion primitives — mutex variants, RAII lock guards, condition variables, and correct patterns for thread-safe code.

A move-only callable wrapper that stores its result or exception in a shared state accessible via std::future.

Write-end of a one-shot, thread-safe channel; pairs with std::future to pass a value or exception across threads.

C++17 reader-writer mutex allowing multiple concurrent shared (read) locks alongside a single exclusive (write) lock, eliminating false serialization of reads.

C++11 portable threading model — thread creation, mutual exclusion, lock-free atomics, and condition-variable signaling for safe concurrent programs.

C++ thread_local — per-thread variables, initialization semantics, destruction order, async pitfalls, and performance characteristics.

Low-level object lifetime utilities for constructing and destroying objects in raw memory without invoking operator new or delete.

C++ custom allocators and C++17 polymorphic memory resources: arena, pool, PMR containers, allocator propagation, and zero-heap hot paths.

C++ memory management — RAII, smart pointers, arenas, PMR allocators, object pools, placement new, and avoiding heap pitfalls.

A non-owning pointer wrapper from the C++ Library Fundamentals TS that makes non-ownership explicit at the type level.

Construct objects in pre-allocated memory using placement new, std::construct_at, std::destroy_at, and std::launder for allocators, pools, and variant storage.

unique_ptr, shared_ptr, and weak_ptr — ownership semantics, control block internals, custom deleters, cycle breaking, and enable_shared_from_this.

C++23 RAII proxy adapters that let smart pointers be passed directly to C-style T** output-parameter APIs without unsafe casts or manual resets.

Abstract base class for C++17 polymorphic memory resources; decouples allocation strategy from container type via runtime polymorphism.

A reference-counted smart pointer that enables shared ownership of a dynamically allocated object, deleting it when the last owner is destroyed.

Exclusive-ownership smart pointer that automatically frees its managed object when it goes out of scope, with zero overhead over a raw pointer.

A non-owning smart pointer that observes a shared_ptr-managed object without extending its lifetime, enabling cycle-breaking and safe expiry detection.

C++ weak_ptr usage patterns — breaking cycles, observers, caches, enable_shared_from_this, and thread-safe access via lock().

Test character properties and convert between uppercase and lowercase using standard library functions.

Header <cstring> provides null-terminated C-style string functions: strlen, strcpy, strcat, strcmp, and memory operations for interop with C code.

Deep dive into std::regex_iterator, regex_token_iterator, regex_replace, capture groups, and regex grammar flags introduced in C++11.

C++20 std::format and C++23 std::print — type-safe formatted output with compile-time checking, custom formatters, and efficient direct printing.

"The C++ standard string class — mutable, owning character sequences with construction, modification, searching, and conversions. Zero-copy alternatives: std::string_view."

Non-owning view of a character sequence. Zero-copy alternative to const std::string&. Accepts literals, std::string, and char arrays without allocation.

C++ string conversions — to_string, stoi/stof, from_chars, to_chars, and std::format with C++ version discipline and performance trade-offs.

Character and string types for wide character sets, including wchar_t, std::wstring, and Unicode-aware character types for international text.

C++20 header providing portable bit manipulation — rotation, counting, power-of-two math, endianness detection, and safe type-punning via bit_cast.

C++11 header for IEEE 754 floating-point environment control — exception flags, rounding modes, and environment save/restore.

Standard C++ header providing mathematical functions for floating-point arithmetic, rounding, classification, and error handling.

Three-way comparison ordering categories, the &lt;=> spaceship operator, and named comparison helpers introduced in C++20.

C-style signal handling in C++ — signal(), raise(), std::sig_atomic_t, and the strict rules for writing portable, async-signal-safe handlers.

Fixed-width integer type aliases and limit macros for portable, size-explicit integer programming in C++.

C++ wrapper for C's stdlib.h, providing process control, raw memory allocation, numeric conversions, integer arithmetic, and pseudo-random numbers.

C++ header providing null-terminated string manipulation and raw memory operation functions inherited from C's <string.h>.

The <functional> header provides function objects, std::function, std::bind, std::invoke, and callable wrappers for composing and passing behavior as first-class values.

Parameterized stream manipulators for field width, fill character, numeric base, floating-point precision, monetary formatting, and date/time I/O.

C++23 header providing stream I/O over std::span<char> buffers — fixed-capacity, zero-allocation alternatives to <sstream>.

C++23 header providing optional fixed-width extended floating-point types including IEEE 754 half, single, double, quad, and bfloat16 formats.

Portable, extensible error-code infrastructure for reporting OS and library errors as values rather than exceptions, introduced in C++11.

The <typeinfo> header provides std::type_info and bad_typeid — C++'s built-in runtime type identification primitives used with the typeid operator.

The <utility> header provides foundational C++ building blocks — move, forward, swap, exchange, pair, declval, and safe integer comparisons.

C++20 header that centralises all standard library feature-test macros for portable compile-time capability detection.

The C++20 <concepts> header provides standard named constraints — std::integral, std::regular, std::invocable — replacing SFINAE boilerplate with readable, composable template interfaces.

<cstdio> exposes C stdio (printf, fopen, snprintf, fread) in namespace std: formatted and binary file I/O, its pitfalls, and modern C++ alternatives.

C++26 <debugging> header — std::breakpoint(), std::is_debugger_present(), and std::breakpoint_if_debugging() for programmatic debugger integration.

The std::exception hierarchy, when to throw each standard type, how to write custom exceptions, and how to nest and transport exceptions across threads.

Tag types and global constants that control whether STL algorithms run sequentially, in parallel, or with SIMD vectorization — introduced in C++17.

File stream classes for reading, writing, and random-access I/O on files; the <fstream> header provides ifstream, ofstream, and fstream.

"C++ iostream system: standard streams, file and string streams, stream state, manipulators, custom operators, rdbuf redirection, and performance tuning."

The <iterator> header provides iterator categories, traits, adaptors, stream iterators, and free functions that bridge containers and algorithms.

"C++ numeric algorithms: accumulate, reduce, transform_reduce, prefix scans, inner_product, iota, gcd, lcm, midpoint, and lerp with parallel execution notes."

C++ <random> engines, distributions, seeding strategies, thread safety, and common pitfalls — from mt19937 to discrete_distribution.

The C++20 ranges library provides composable, lazy sequences with concept-constrained algorithms and view adaptors via the pipe operator.

std::reference_wrapper, std::ref and std::cref: copyable, assignable reference semantics for containers, bind, threads and generic callables.

Header providing std::istringstream, std::ostringstream, and std::stringstream for in-memory formatted I/O on std::string buffers.

Type-safe, type-erased container for a single value of any copy-constructible type, with runtime type queries and checked casts.

Thread-safe atomic operations without mutexes — memory orders, CAS loops, atomic_flag, atomic_ref (C++20), wait/notify (C++20), and lock-free patterns.

std::bind, bind_front and bind_back: partial application, argument reordering and placeholders, with version history and when lambdas are the better choice.

Fixed-size bit manipulation with set/reset/flip/test, bitwise operators, and integer/string conversions — stack-allocated, no heap, no UB from shift overflow.

Type-safe time and duration library — durations, clocks, time points, and C++20 calendar and timezone types.

Advanced C++ chrono covering C++20 calendar types, time zones, zoned_time, date arithmetic, DST edge cases, formatting, and clock selection.

Class template for complex number arithmetic with real and imaginary parts, arithmetic operators, math functions, and C++14 literals.

C++23 vocabulary type holding either a success value T or an error value E, making failure modes explicit in the return type without exceptions.

Cross-platform filesystem operations in C++17 — path manipulation, directory traversal, file status queries, and file I/O utilities.

C++23 sorted contiguous-memory container adapters with O(log n) binary search and cache-friendly layout — no pointer chasing through tree nodes.

Type-safe, compile-time-checked text formatting introduced in C++20, replacing printf and stream-based output with Python-style format strings.

C++17 charconv — locale-independent, non-allocating, non-throwing conversion between numbers and character buffers.

A general-purpose polymorphic function wrapper that type-erases any callable matching a given signature, at the cost of runtime overhead.

std::hash specialization, hash_combine design, transparent heterogeneous lookup (C++20), and custom hash requirements for unordered containers.

A lightweight, read-only view over a compiler-generated const array that enables brace-initialization syntax for functions and constructors.

Fixed-capacity vector with inline storage — dynamic size 0..N, no heap allocation, constexpr-compatible, and full std::vector-compatible API.

Uniformly call any callable (function, member pointer, functor, lambda) with std::invoke (C++17), std::invoke_r (C++23), and std::is_invocable traits.

C++26 BLAS-level 1/2/3 free functions operating on std::mdspan views for portable dense linear algebra without external library dependencies.

Multi-dimensional non-owning view over contiguous data with pluggable layout and accessor policies. C++23 replacement for raw pointer and stride arithmetic.

C++20 compile-time mathematical constants (π, e, φ, √2, and more) in <numbers>, available as double aliases and as precision-preserving variable templates.

Class template providing compile-time type properties — range, precision, and representation flags — for all arithmetic types, replacing C-style macros.

A value-or-nothing wrapper that eliminates sentinel values and nullable pointer workarounds in C++17.

C++23 and_then, transform, and or_else on std::optional enable composable error-propagation pipelines without nested nullopt checks.

C++20 synchronized output stream that atomically transfers buffered content to a wrapped ostream, eliminating interleaved output in multithreaded programs.

std::pair and std::tuple store multiple values. Structured bindings, std::tie, std::apply, and composition patterns for heterogeneous data.

Compile-time rational number arithmetic via template parameters — the unit system underlying std::chrono::duration.

C++ regular expressions — regex_match, regex_search, regex_replace, capture groups, iterators, and when to reach for a faster library.

C++11 allocator adaptor that propagates one or more allocators through every nesting level of a container hierarchy via std::uses_allocator.

std::simd<T, Abi>: type-safe portable SIMD in C++26 (P1928) — write vectorized code once, compile to SSE/AVX/NEON/SVE automatically without intrinsics or platform ifdefs.

Capture file, line, column, and function name at the call site without macros — the C++20 replacement for __FILE__ and __LINE__.

Non-owning view over a contiguous sequence of objects. C++20's type-safe replacement for (pointer, length) pairs, working with arrays, vectors, std::array, and raw buffers.

Capture and inspect runtime call stacks with std::stacktrace — frame iteration, exception integration, allocator control, and compiler setup.

"C++20 cooperative cancellation primitives: stop_token, stop_source, stop_callback, and jthread integration for safe thread shutdown."

Abstract base class for C++ stream buffers, mediating raw character I/O between higher-level streams and the underlying data device.

"Non-owning, read-only string reference (C++17): zero-copy substrings, universal parameter type, constexpr usage, and lifetime hazards."

Fixed-size heterogeneous collections with value semantics — pair for two values, tuple for N values of any types, with structured bindings support.

A copyable, hashable wrapper around std::type_info enabling runtime type information to be used as keys in associative containers.

Numeric array with element-wise arithmetic, built-in math functions, and slice-based sub-array access for high-performance numerical computing.

Type-safe tagged union holding exactly one of a fixed set of alternative types, introduced in C++17 with no heap allocation.

C++ string operations — searching, splitting, trimming, case conversion, replace-all, and fast number parsing with from_chars and string_view.

Fast, locale-independent parsing with from_chars/to_chars (C++17), convenient stoi/stod (C++11), and locale-aware formatting via std::locale and its facets.

std::swap, std::exchange, and std::iter_swap: semantics, noexcept rules, the ADL swap idiom, and how to implement move operations and copy-and-swap correctly.

C++ character types, encoding-aware string types, and conversion facilities for UTF-8, UTF-16, UTF-32, and locale-dependent encodings.

C-style date and time facilities in <ctime>: time_t, tm, clock, localtime, gmtime, strftime, and safe interop with std::chrono.

"Compile-time type inspection and transformation via <type_traits>: primary categories, property queries, type modifications, and custom trait authoring."