Utilities & Strings

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 <=> 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.

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

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.

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

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.

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

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++20 std::format and C++23 std::print — type-safe formatted output with compile-time checking, custom formatters, and efficient direct printing.

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.

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

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

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

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.

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

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."

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