Utility library

From cppreference.com
< cpp

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.


[edit] Language support

Language support libraries provide classes and functions that interact closely with language features and support common language idioms.

[edit] 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)

[edit] Dynamic memory management

Smart pointers (e.g. std::shared_ptr), allocators (e.g. std::allocator), C-style memory management (e.g. std::malloc)

[edit] Error handling

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

[edit] Initializer lists

allows the use of initializer list syntax to initialize non plain-old-data types
(class template)

[edit] Variadic functions

Support for functions that take an arbitrary number of parameters (via e.g. va_start, va_arg, va_end)

[edit] General-purpose utilities

[edit] Program utilities

Termination (e.g. std::abort, std::atexit), environment (e.g. std::system), signals (e.g. std::raise)

[edit] 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)

[edit] Bitset

implements constant length bit array

[edit] 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), method to function converters std::mem_fn.

[edit] Pairs and tuples

implements binary tuple, i.e. a pair of values
(class template)
implements fixed size container, which holds elements of possibly different types
(class template)
tag type used to select correct function overload for piecewise construction
an object of type piecewise_construct_t used to disambiguate functions for piecewise construction
implements compile-time sequence of integers
(class template)

[edit] Swap, forward and move

swaps the values of two objects
(function template)
replaces the argument with a new value and returns its previous value
(function template)
forwards a function argument
(function template)
obtains an rvalue reference
(function template)
obtains an rvalue reference if the move constructor does not throw
(function template)
obtains the type of expression in unevaluated context
(function template)

[edit] Relational operators

Defined in namespace std::rel_ops
automatically generates comparison operators based on user-defined operator== and operator<
(function template)

[edit] Hash support

hash function object
(class template)