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.
Type support
Basic types (e.g. std::size_t , std::nullptr_t ), RTTI (e.g. std::type_info )
Metaprogramming
Type traits (e.g. std::is_integral , std::rank ), compile-time constants (e.g. std::integer_sequence , std::ratio )
Constant evaluation context
|
Defined in header
<type_traits>
|
|
|
(C++20)
|
detects whether the call occurs within a constant-evaluated context
(function) |
|
(C++26)
|
checks whether a pointer is within the object's lifetime at compile time
(function) |
Implementation properties
|
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 . |
(since C++20) |
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 )
Source code information capture
|
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) |
Initializer lists
|
Defined in header
<initializer_list>
|
|
|
(C++11)
|
references a temporary array created in
list-initialization
(class template) |
Three-way comparison
|
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
|
Types for coroutine support, e.g. std::coroutine_traits , std::coroutine_handle . |
(since C++20) |
Variadic functions
Support for functions that take an arbitrary number of parameters (via e.g. va_start , va_arg , va_end ).
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
|
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
|
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
|
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
|
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 |
|
|
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
|
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) |
|
Function objects
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
|
Defined in header
<functional>
|
|
|
(C++11)
|
hash function object
(class template) |
Date and time
Time tracking (e.g. std::chrono::time_point , std::chrono::duration ), C-style date and time (e.g. std::time , std::clock )
Primitive string conversions
In addition to sophisticated locale-dependent parsers and formatters provided by the C++ I/O library, the C I/O library, C++ string converters , and C string converters , the header <charconv> provides light-weight, locale-independent, non-allocating, non-throwing parsers and formatters for arithmetic types.
|
Defined in header
<charconv>
|
|
|
(C++17)
|
converts an integer or floating-point value to a character sequence
(function) |
|
(C++17)
|
the return type of
std::to_chars
(class) |
|
(C++17)
|
converts a character sequence to an integer or floating-point value
(function) |
|
(C++17)
|
the return type of
std::from_chars
(class) |
|
(C++17)
|
specifies formatting for
std::to_chars
and
std::from_chars
(enum) |
Formatting library
Facilities for type-safe string formatting.
|
Defined in header
<format>
|
|
|
(C++20)
|
stores formatted representation of the arguments in a new string
(function template) |
|
(C++20)
|
writes out formatted representation of its arguments through an output iterator
(function template) |
|
(C++20)
|
writes out formatted representation of its arguments through an output iterator, not exceeding specified size
(function template) |
|
(C++20)
|
determines the number of characters necessary to store the formatted representation of its arguments
(function template) |
|
(C++20)
|
non-template variant of
std::format
using type-erased argument representation
(function) |
|
(C++20)
|
non-template variant of
std::format_to
using type-erased argument representation
(function template) |
|
(C++20)
|
defines formatting rules for a given type
(class template) |
|
(C++20)
|
exception type thrown on formatting errors
(class) |
See also
|
C documentation
for
Utility library
|