Utility library

From cppreference.com
< cpp
 
 
Utilities library
General utilities
Date and time
Function objects
Formatting library (C++20)
(C++11)
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Elementary string conversions
(C++17)
(C++17)
 

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), type traits (e.g. std::is_integral, std::rank)

Constant evaluation context

Defined in header <type_traits>
detects whether the call occurs within a constant-evaluated context
(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)

Object access

Defined in header <new>
(C++17)
pointer optimization barrier
(function template)

Error handling

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

Source code information capture

Defined in header <source_location>
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>
creates a temporary array in list-initialization and then references it
(class template)

Three-way comparison

Defined in header <compare>
specifies that operator <=> produces consistent result on given types
(concept)
the result type of 3-way comparison that supports all 6 operators, is not substitutable, and allows incomparable values
(class)
the result type of 3-way comparison that supports all 6 operators and is not substitutable
(class)
the result type of 3-way comparison that supports all 6 operators and is substitutable
(class)
named comparison functions
(function)
function object implementing x <=> y
(class)
obtains the result type of the three-way comparison operator <=> on given types
(class template)
the strongest comparison category to which all of the given types can be converted
(class template)
performs 3-way comparison and produces a result of type std::strong_ordering
(customization point object)
performs 3-way comparison and produces a result of type std::weak_ordering
(customization point object)
performs 3-way comparison and produces a result of type std::partial_ordering
(customization point object)
performs 3-way comparison and produces a result of type std::strong_ordering, even if operator<=> is unavailable
(customization point object)
performs 3-way comparison and produces a result of type std::weak_ordering, even if operator<=> is unavailable
(customization point object)
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 and type operations

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)
(C++11)
forwards a function argument
(function template)
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)
obtains an rvalue reference
(function template)
obtains an rvalue reference 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 its argument for use in unevaluated context
(function template)
converts an enumeration to its underlying type
(function template)
Defined in header <concepts>
swaps the values of two objects
(customization point object)

Integer comparison functions

Defined in header <utility>
compares two integer values without value change caused by conversion
(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
automatically generates comparison operators based on user-defined operator== and operator<
(function template)

Pairs and tuples

Defined in header <utility>
implements binary tuple, i.e. a pair of values
(class template)
an object of type piecewise_construct_t used to disambiguate functions for piecewise construction
(constant)
implements compile-time sequence of integers
(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)
Construct an object with a tuple of arguments
(function template)
 
Defined in header <tuple>
Defined in header <utility>
Defined in header <array>
Defined in header <ranges>
obtains the number of elements of a tuple-like type
(class template)
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)
 
Defined in header <utility>
in-place construction tag
(class template)

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)

Elementary 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)
converts a character sequence to an integer or floating-point value
(function)
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)
writes out formatted representation of its arguments through an output iterator, not exceeding specified size
(function template)
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)
non-template variant of std::format_to using type-erased argument representation
(function template)
(C++20)
class template that defines formatting rules for a given type
(class template)
exception type thrown on formatting errors
(class)

See also