C++ includes a variety of utility libraries that provide functionality ranging from bit-counting to partial function application. These libraries can be broadly divided into two groups:

• language support libraries, and
• general-purpose libraries.

Language support

Language support libraries provide classes and functions that interact closely with language features and support common language idioms.

Implementation properties (since C++20)

The header <version> supplies implementation-dependent information about the C++ standard library (such as the version number and release date). It also defines the library feature-test macros.

Type support

Basic types (e.g. std::size_t, std::nullptr_t), RTTI (e.g. std::type_info)

Program utilities

Termination (e.g. std::abort, std::atexit), environment (e.g. std::system), signals (e.g. std::raise).

Dynamic memory management

Smart pointers (e.g. std::shared_ptr), allocators (e.g. std::allocator or std::pmr::memory_resource), C-style memory management (e.g. std::malloc).

Error handling

Exceptions (e.g. std::exception, std::terminate), assertions (e.g. assert).

Variadic functions

Support for functions that take an arbitrary number of parameters (via e.g. va_start, va_arg, va_end).

Initializer lists (since C++11)

Source code information capture (since C++20)

Three-way comparison (since C++20)

Defined in header <compare>
three_way_comparablethree_way_comparable_with (C++20)	specifies that operator <=> produces consistent result on given types (concept) [edit]
partial_ordering (C++20)	the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values (class) [edit]
weak_ordering (C++20)	the result type of 3-way comparison that supports all 6 operators and is not substitutable (class) [edit]
strong_ordering (C++20)	the result type of 3-way comparison that supports all 6 operators and is substitutable (class) [edit]
is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)	named comparison functions (function) [edit]
compare_three_way (C++20)	constrained function object implementing x <=> y (class) [edit]
compare_three_way_result (C++20)	obtains the result type of the three-way comparison operator <=> on given types (class template) [edit]
common_comparison_category (C++20)	the strongest comparison category to which all of the given types can be converted (class template) [edit]
strong_order (C++20)	performs 3-way comparison and produces a result of type std::strong_ordering (customization point object)[edit]
weak_order (C++20)	performs 3-way comparison and produces a result of type std::weak_ordering (customization point object)[edit]
partial_order (C++20)	performs 3-way comparison and produces a result of type std::partial_ordering (customization point object)[edit]
compare_strong_order_fallback (C++20)	performs 3-way comparison and produces a result of type std::strong_ordering, even if operator<=> is unavailable (customization point object)[edit]
compare_weak_order_fallback (C++20)	performs 3-way comparison and produces a result of type std::weak_ordering, even if operator<=> is unavailable (customization point object)[edit]
compare_partial_order_fallback (C++20)	performs 3-way comparison and produces a result of type std::partial_ordering, even if operator<=> is unavailable (customization point object)[edit]

Coroutine support (since C++20)

Types for coroutine support (e.g. std::coroutine_traits, std::coroutine_handle).

Contract support (since C++26)

Types for contract support (e.g. std::contracts::contract_violation).

General-purpose utilities

Swap

	swaps the values of two objects (function template) [edit]
	replaces the argument with a new value and returns its previous value (function template) [edit]
	swaps the values of two objects (customization point object)[edit]

Type operations (since C++11)

Defined in header <utility>
forward (C++11)	forwards a function argument and use the type template argument to preserve its value category (function template) [edit]
forward_like (C++23)	forwards a function argument as if casting it to the value category and constness of the expression of specified type template argument (function template) [edit]
move (C++11)	converts the argument to an xvalue (function template) [edit]
move_if_noexcept (C++11)	converts the argument to an xvalue if the move constructor does not throw (function template) [edit]
as_const (C++17)	obtains a reference to const to its argument (function template) [edit]
declval (C++11)	obtains a reference to an object of the template type argument for use in an unevaluated context (function template) [edit]
to_underlying (C++23)	converts an enumeration to its underlying type (function template) [edit]

Integer comparison functions (since C++20)

Relational operators (until C++20)

Construction tags (since C++11)

Pairs and tuples

Defined in header <utility>
pair	implements binary tuple, i.e. a pair of values (class template) [edit]
Defined in header <tuple>
tuple (C++11)	implements fixed size container, which holds elements of possibly different types (class template) [edit]
apply (C++17)	calls a function with a tuple of arguments (function template) [edit]
make_from_tuple (C++17)	construct an object with a tuple of arguments (function template) [edit]
Tuple protocol (since C++11)
Defined in header <tuple>
Defined in header <utility>
Defined in header <array>
Defined in header <ranges>
Defined in header <complex>
tuple_size (C++11)	obtains the number of elements of a tuple-like type (class template) [edit]
tuple_element (C++11)	obtains the element types of a tuple-like type (class template) [edit]

Sum types and type erased wrappers (since C++17)

Defined in header <optional>
optional (C++17)	a wrapper that may or may not hold an object (class template) [edit]
Defined in header <expected>
expected (C++23)	a wrapper that contains either an expected or error value (class template) [edit]
Defined in header <variant>
variant (C++17)	a type-safe discriminated union (class template) [edit]
Defined in header <any>
any (C++17)	objects that hold instances of any CopyConstructible type (class) [edit]

Bitset

Bit manipulation (since C++20)

The header <bit> provides several function templates to access, manipulate, and process individual bits and bit sequences. The byte ordering (endianness) of scalar types can be inspected via std::endian facility.

Function objects (since C++11)

Partial function application (e.g. std::bind) and related utilities: utilities for binding such as std::ref and std::placeholders, polymorphic function wrappers: std::function, predefined functors (e.g. std::plus, std::equal_to), pointer-to-member to function converters std::mem_fn.

Hash support (since C++11)

See also