W3cubDocs

/C++

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

Constant evaluation context

Defined in header <type_traits>
(C++20)
 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).

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

Three-way comparison

Defined in header <compare>
(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)
 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
(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)
 obtains an rvalue reference
(function template)
(C++11)
 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)
(C++23)
 converts an enumeration to its underlying type
(function template)

Integer comparison functions

Defined in header <utility>
(C++20)
 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
(deprecated in C++20)
 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)
(C++11)
 an object of type piecewise_construct_t used to disambiguate functions for piecewise construction
(constant)
(C++14)
 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)
(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>
(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)
Defined in header <utility>
(C++17)
 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)
(C++17)
 converts a character sequence to an integer or floating-point value
(function)
(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)
 class template that 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

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility