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> |
|
|---|---|
|
(C++20)(C++20) | 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) |
|
(C++20) | 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) |
|
(C++26) | performs three-way comparison on types (class template) |
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> |
|
|---|---|
|
(C++20) | 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> |
|
|---|---|
|
(C++11) | piecewise construction tag (tag) |
|
(C++17) | 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 |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility
