Utility library
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)
|
Defined in header
<initializer_list>
|
|
|
(C++11)
|
references a temporary array created in
list-initialization
(class template) |
Source code information capture (since C++20)
|
Defined in header
<source_location>
|
|
|
(C++20)
|
a class representing information about the source code, such as file names, line numbers, and function names
(class) |
Three-way comparison (since C++20)
|
Defined in header
<compare>
|
|
|
specifies that operator
<=>
produces consistent result on given types
(concept) |
|
|
(C++20)
|
the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values
(class) |
|
(C++20)
|
the result type of 3-way comparison that supports all 6 operators and is not substitutable
(class) |
|
(C++20)
|
the result type of 3-way comparison that supports all 6 operators and is substitutable
(class) |
|
named comparison functions
(function) |
|
|
(C++20)
|
constrained function object implementing
x
<=>
y
(class) |
|
(C++20)
|
obtains the result type of the three-way comparison operator
<=>
on given types
(class template) |
|
(C++20)
|
the strongest comparison category to which all of the given types can be converted
(class template) |
|
(C++20)
|
performs 3-way comparison and produces a result of type
std::strong_ordering
(customization point object) |
|
(C++20)
|
performs 3-way comparison and produces a result of type
std::weak_ordering
(customization point object) |
|
(C++20)
|
performs 3-way comparison and produces a result of type
std::partial_ordering
(customization point object) |
|
(C++20)
|
performs 3-way comparison and produces a result of type
std::strong_ordering
, even if
operator
<=>
is unavailable
(customization point object) |
|
(C++20)
|
performs 3-way comparison and produces a result of type
std::weak_ordering
, even if
operator
<=>
is unavailable
(customization point object) |
|
(C++20)
|
performs 3-way comparison and produces a result of type
std::partial_ordering
, even if
operator
<=>
is unavailable
(customization point object) |
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
|
Defined in header
<utility>
|
|
|
swaps the values of two objects
(function template) |
|
|
(C++14)
|
replaces the argument with a new value and returns its previous value
(function template) |
|
Defined in header
<concepts>
|
|
|
(C++20)
|
swaps the values of two objects
(customization point object) |
Type operations (since C++11)
|
Defined in header
<utility>
|
|
|
(C++11)
|
forwards a function argument and use the type template argument to preserve its value category
(function template) |
|
(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) |
|
(C++11)
|
converts the argument to an xvalue
(function template) |
|
(C++11)
|
converts the argument to an xvalue if the move constructor does not throw
(function template) |
|
(C++17)
|
obtains a reference to
const
to its argument
(function template) |
|
(C++11)
|
obtains a reference to an object of the template type argument for use in an unevaluated context
(function template) |
|
(C++23)
|
converts an enumeration to its underlying type
(function template) |
Integer comparison functions (since C++20)
|
Defined in header
<utility>
|
|
|
compares two integer values, ensuring that signed negative numbers are less than unsigned numbers
(function template) |
|
|
(C++20)
|
checks if an integer value is in the range of a given integer type
(function template) |
Relational operators (until C++20)
|
Defined in header
<utility>
|
|
|
Defined in namespace
std::rel_ops
|
|
|
(deprecated in C++20)
|
automatically generates comparison operators based on user-defined
operator
==
and
operator
<
(function template) |
Construction tags (since C++11)
|
Defined in header
<utility>
|
|
|
piecewise construction tag
(tag) |
|
|
in-place construction tag
(tag) |
|
|
(C++26)
|
value construction tag
(tag) |
Pairs and tuples
|
Defined in header
<utility>
|
|
|
implements binary tuple, i.e. a pair of values
(class template) |
|
|
Defined in header
<tuple>
|
|
|
(C++11)
|
implements fixed size container, which holds elements of possibly different types
(class template) |
|
(C++17)
|
calls a function with a tuple of arguments
(function template) |
|
(C++17)
|
construct an object with a tuple of arguments
(function template) |
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>
|
|
|
(C++11)
|
obtains the number of elements of a tuple-like type
(class template) |
|
(C++11)
|
obtains the element types of a tuple-like type
(class template) |
Sum types and type erased wrappers (since C++17)
|
Defined in header
<optional>
|
|
|
(C++17)
|
a wrapper that may or may not hold an object
(class template) |
|
Defined in header
<expected>
|
|
|
(C++23)
|
a wrapper that contains either an expected or error value
(class template) |
|
Defined in header
<variant>
|
|
|
(C++17)
|
a type-safe discriminated union
(class template) |
|
Defined in header
<any>
|
|
|
(C++17)
|
objects that hold instances of any
CopyConstructible
type
(class) |
Bitset
|
Defined in header
<bitset>
|
|
|
implements constant length bit array
(class template) |
|
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)
|
Defined in header
<functional>
|
|
|
(C++11)
|
hash function object
(class template) |
See also
|
C documentation
for
Utility library
|