Utilities
Collaboration diagram for Utilities:

## Modules

| Function Objects
| Memory
| Metaprogramming
| Rational Arithmetic
| Time

## Classes

struct | std::_Tuple_impl< _Idx, _Elements >
class | std::optional< _Tp >
class | std::tuple< _Elements >
struct | std::tuple_element< __i, tuple< _Head, _Tail... > >
struct | std::tuple_size< tuple< _Elements... > >
struct | std::uses_allocator< tuple< _Types... >, _Alloc >

## Macros

#define | __cpp_lib_addressof_constexpr
#define | __cpp_lib_any
#define | __cpp_lib_apply
#define | __cpp_lib_make_from_tuple
#define | __cpp_lib_optional
#define | __cpp_lib_tuples_by_type

## Typedefs

template<typename _Tp , typename _Up >
using | std::__assigns_from_optional = __or_< is_assignable< _Tp &, const optional< _Up > & >, is_assignable< _Tp &, optional< _Up > & >, is_assignable< _Tp &, const optional< _Up > && >, is_assignable< _Tp &, optional< _Up > && > >
template<typename _Tp , typename _Up >

using

std::__converts_from_optional = __or_< is_constructible< _Tp, const optional< _Up > & >, is_constructible< _Tp, optional< _Up > & >, is_constructible< _Tp, const optional< _Up > && >, is_constructible< _Tp, optional< _Up > && >, is_convertible< const optional< _Up > &, _Tp >, is_convertible< optional< _Up > &, _Tp >, is_convertible< const optional< _Up > &&, _Tp >, is_convertible< optional< _Up > &&, _Tp > >

template<typename _Tp >
using | std::__empty_not_final = typename conditional< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp > >::type
template<typename _Tp , typename _Up >
using | std::__optional_eq_t = __optional_relop_t< decltype(std::declval< const _Tp & >()==std::declval< const _Up & >()) >
template<typename _Tp , typename _Up >
using | std::__optional_ge_t = __optional_relop_t< decltype(std::declval< const _Tp & >() >=std::declval< const _Up & >()) >
template<typename _Tp , typename _Up >
using | std::__optional_gt_t = __optional_relop_t< decltype(std::declval< const _Tp & >() > std::declval< const _Up & >()) >
template<typename _Tp , typename _Up >
using | std::__optional_le_t = __optional_relop_t< decltype(std::declval< const _Tp & >()<=std::declval< const _Up & >()) >
template<typename _Tp , typename _Up >
using | std::__optional_lt_t = __optional_relop_t< decltype(std::declval< const _Tp & >()< std::declval< const _Up & >()) >
template<typename _Tp , typename _Up >
using | std::__optional_ne_t = __optional_relop_t< decltype(std::declval< const _Tp & >() !=std::declval< const _Up & >()) >
template<typename _Tp >
using | std::__optional_relop_t = enable_if_t< is_convertible< _Tp, bool >::value, bool >

## Functions

template<typename... _Args1, typename... _Args2>
constexpr | std::pair< _T1, _T2 >::pair (piecewise_construct_t, tuple< _Args1... >, tuple< _Args2... >)
template<typename _Tp >
constexpr _Tp * | std::__addressof (_Tp &__r) noexcept
template<typename _Fn , typename _Tuple , size_t... _Idx>
constexpr decltype(auto) | std::__apply_impl (_Fn &&__f, _Tuple &&__t, index_sequence< _Idx... >)
template<typename _Tp , typename _Up = _Tp>
constexpr _Tp | std::__exchange (_Tp &__obj, _Up &&__new_val)
template<typename _Tp , typename... _Types>
constexpr size_t | std::__find_uniq_type_in_pack ()
template<size_t __i, typename _Head , typename... _Tail>
constexpr _Head & | std::__get_helper (_Tuple_impl< __i, _Head, _Tail... > &__t) noexcept
template<size_t __i, typename _Head , typename... _Tail>
constexpr const _Head & | std::__get_helper (const _Tuple_impl< __i, _Head, _Tail... > &__t) noexcept
template<size_t __i, typename... _Types>
__enable_if_t<(__i >=sizeof...(_Types))> | std::__get_helper (const tuple< _Types... > &)=delete
template<typename _Tp , typename _Up = typename __inv_unwrap<_Tp>::type>
constexpr _Up && | std::__invfwd (typename remove_reference< _Tp >::type &__t) noexcept
template<typename _Callable , typename... _Args>
constexpr __invoke_result< _Callable, _Args... >::type | std::__invoke (_Callable &&__fn, _Args &&... __args) noexcept(__is_nothrow_invocable< _Callable, _Args... >::value)
template<typename _Res , typename _MemFun , typename _Tp , typename... _Args>
constexpr _Res | std::__invoke_impl (__invoke_memfun_deref, _MemFun &&__f, _Tp &&__t, _Args &&... __args)
template<typename _Res , typename _MemFun , typename _Tp , typename... _Args>
constexpr _Res | std::__invoke_impl (__invoke_memfun_ref, _MemFun &&__f, _Tp &&__t, _Args &&... __args)
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res | std::__invoke_impl (__invoke_memobj_deref, _MemPtr &&__f, _Tp &&__t)
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res | std::__invoke_impl (__invoke_memobj_ref, _MemPtr &&__f, _Tp &&__t)
template<typename _Res , typename _Fn , typename... _Args>
constexpr _Res | std::__invoke_impl (__invoke_other, _Fn &&__f, _Args &&... __args)
template<typename _Res , typename _Callable , typename... _Args>
constexpr enable_if_t< is_invocable_r_v< _Res, _Callable, _Args... >, _Res > | std::__invoke_r (_Callable &&__fn, _Args &&... __args) noexcept(is_nothrow_invocable_r_v< _Res, _Callable, _Args... >)
template<typename _Tp , typename _Tuple , size_t... _Idx>
constexpr _Tp | std::__make_from_tuple_impl (_Tuple &&__t, index_sequence< _Idx... >)
void | std::__throw_bad_any_cast ()
void | std::__throw_bad_optional_access ()
static void | std::any::_Manager_internal< _Tp >::_S_manage (_Op __which, const any *__anyp, _Arg *__arg)
static void | std::any::_Manager_external< _Tp >::_S_manage (_Op __which, const any *__anyp, _Arg *__arg)
template<typename _Tp >
constexpr _Tp * | std::addressof (_Tp &__r) noexcept
template<typename _Tp >
const _Tp * | std::addressof (const _Tp &&)=delete
template<typename _ValueType >
_ValueType | std::any_cast (const any &__any)
template<typename _Fn , typename _Tuple >
constexpr decltype(auto) | std::apply (_Fn &&__f, _Tuple &&__t) noexcept(__unpack_std_tuple< is_nothrow_invocable, _Fn, _Tuple >)
template<typename _Tp >
auto | std::declval () noexcept -> decltype(__declval< _Tp >(0))
template<typename _Tp >
constexpr _Tp && | std::forward (typename std::remove_reference< _Tp >::type &&__t) noexcept
template<typename _Tp >
constexpr _Tp && | std::forward (typename std::remove_reference< _Tp >::type &__t) noexcept
template<typename... _Elements>
constexpr tuple< _Elements &&... > | std::forward_as_tuple (_Elements &&... __args) noexcept
template<size_t __i, typename... _Elements>
constexpr const __tuple_element_t< __i, tuple< _Elements... > > && | std::get (const tuple< _Elements... > &&__t) noexcept
template<size_t __i, typename... _Elements>
constexpr const __tuple_element_t< __i, tuple< _Elements... > > & | std::get (const tuple< _Elements... > &__t) noexcept
template<typename _Tp , typename... _Types>
constexpr const _Tp && | std::get (const tuple< _Types... > &&__t) noexcept
template<typename _Tp , typename... _Types>
constexpr const _Tp & | std::get (const tuple< _Types... > &__t) noexcept
template<size_t __i, typename... _Elements>
constexpr __tuple_element_t< __i, tuple< _Elements... > > && | std::get (tuple< _Elements... > &&__t) noexcept
template<size_t __i, typename... _Elements>
constexpr __tuple_element_t< __i, tuple< _Elements... > > & | std::get (tuple< _Elements... > &__t) noexcept
template<typename _Tp , typename... _Types>
constexpr _Tp && | std::get (tuple< _Types... > &&__t) noexcept
template<typename _Tp , typename... _Types>
constexpr _Tp & | std::get (tuple< _Types... > &__t) noexcept
template<typename _Tp , typename... _Args>
enable_if_t< is_constructible_v< any, in_place_type_t< _Tp >, _Args... >, any > | std::make_any (_Args &&... __args)
template<typename _Tp , typename _Up , typename... _Args>
enable_if_t< is_constructible_v< any, in_place_type_t< _Tp >, initializer_list< _Up > &, _Args... >, any > | std::make_any (initializer_list< _Up > __il, _Args &&... __args)
template<typename _Tp , typename _Tuple >
constexpr _Tp | std::make_from_tuple (_Tuple &&__t) noexcept(__unpack_std_tuple< is_nothrow_constructible, _Tp, _Tuple >)
template<typename _Tp , typename... _Args>
constexpr enable_if_t< is_constructible_v< _Tp, _Args... >, optional< _Tp > > | std::make_optional (_Args &&... __args) noexcept(is_nothrow_constructible_v< _Tp, _Args... >)
template<typename _Tp >
constexpr enable_if_t< is_constructible_v< decay_t< _Tp >, _Tp >, optional< decay_t< _Tp > > > | std::make_optional (_Tp &&__t) noexcept(is_nothrow_constructible_v< optional< decay_t< _Tp >>, _Tp >)
template<typename _Tp , typename _Up , typename... _Args>
constexpr enable_if_t< is_constructible_v< _Tp, initializer_list< _Up > &, _Args... >, optional< _Tp > > | std::make_optional (initializer_list< _Up > __il, _Args &&... __args) noexcept(is_nothrow_constructible_v< _Tp, initializer_list< _Up > &, _Args... >)
template<typename _T1 , typename _T2 >
constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > | make_pair (_T1 &&__x, _T2 &&__y)
template<typename... _Elements>
constexpr tuple< typename __decay_and_strip< _Elements >::__type... > | std::make_tuple (_Elements &&... __args)
template<typename _Tp >
constexpr std::remove_reference< _Tp >::type && | std::move (_Tp &&__t) noexcept
template<typename _Tp >
constexpr conditional< __move_if_noexcept_cond< _Tp >::value, const _Tp &, _Tp && >::type | std::move_if_noexcept (_Tp &__x) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator!= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_ne_t< _Up, _Tp >
template<typename _Tp , typename _Up >
constexpr auto | std::operator!= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_ne_t< _Tp, _Up >
template<typename _Tp , typename _Up >
constexpr auto | std::operator!= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_ne_t< _Tp, _Up >
template<typename _Tp >
constexpr bool | std::operator!= (const optional< _Tp > &__lhs, nullopt_t) noexcept
template<typename... _TElements, typename... _UElements>
constexpr bool | std::operator!= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
template<typename _Tp >
constexpr bool | std::operator!= (nullopt_t, const optional< _Tp > &__rhs) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator< (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_lt_t< _Up, _Tp >
template<typename _Tp >
constexpr bool | std::operator< (const optional< _Tp > &, nullopt_t) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator< (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_lt_t< _Tp, _Up >
template<typename _Tp , typename _Up >
constexpr auto | std::operator< (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_lt_t< _Tp, _Up >
template<typename... _TElements, typename... _UElements>
constexpr bool | std::operator< (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
template<typename _Tp >
constexpr bool | std::operator< (nullopt_t, const optional< _Tp > &__rhs) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator<= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_le_t< _Up, _Tp >
template<typename _Tp , typename _Up >
constexpr auto | std::operator<= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_le_t< _Tp, _Up >
template<typename _Tp , typename _Up >
constexpr auto | std::operator<= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_le_t< _Tp, _Up >
template<typename _Tp >
constexpr bool | std::operator<= (const optional< _Tp > &__lhs, nullopt_t) noexcept
template<typename... _TElements, typename... _UElements>
constexpr bool | std::operator<= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
template<typename _Tp >
constexpr bool | std::operator<= (nullopt_t, const optional< _Tp > &) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator== (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_eq_t< _Up, _Tp >
template<typename _Tp , typename _Up >
constexpr auto | std::operator== (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_eq_t< _Tp, _Up >
template<typename _Tp , typename _Up >
constexpr auto | std::operator== (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_eq_t< _Tp, _Up >
template<typename _Tp >
constexpr bool | std::operator== (const optional< _Tp > &__lhs, nullopt_t) noexcept
template<typename... _TElements, typename... _UElements>
constexpr bool | std::operator== (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
template<typename _Tp >
constexpr bool | std::operator== (nullopt_t, const optional< _Tp > &__rhs) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator> (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_gt_t< _Up, _Tp >
template<typename _Tp , typename _Up >
constexpr auto | std::operator> (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_gt_t< _Tp, _Up >
template<typename _Tp , typename _Up >
constexpr auto | std::operator> (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_gt_t< _Tp, _Up >
template<typename _Tp >
constexpr bool | std::operator> (const optional< _Tp > &__lhs, nullopt_t) noexcept
template<typename... _TElements, typename... _UElements>
constexpr bool | std::operator> (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
template<typename _Tp >
constexpr bool | std::operator> (nullopt_t, const optional< _Tp > &) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator>= (const _Up &__lhs, const optional< _Tp > &__rhs) -> __optional_ge_t< _Up, _Tp >
template<typename _Tp >
constexpr bool | std::operator>= (const optional< _Tp > &, nullopt_t) noexcept
template<typename _Tp , typename _Up >
constexpr auto | std::operator>= (const optional< _Tp > &__lhs, const _Up &__rhs) -> __optional_ge_t< _Tp, _Up >
template<typename _Tp , typename _Up >
constexpr auto | std::operator>= (const optional< _Tp > &__lhs, const optional< _Up > &__rhs) -> __optional_ge_t< _Tp, _Up >
template<typename... _TElements, typename... _UElements>
constexpr bool | std::operator>= (const tuple< _TElements... > &__t, const tuple< _UElements... > &__u)
template<typename _Tp >
constexpr bool | std::operator>= (nullopt_t, const optional< _Tp > &__rhs) noexcept
template<typename _Tp >
constexpr enable_if< __and_< __not_< __is_tuple_like< _Tp > >, is_move_constructible< _Tp >, is_move_assignable< _Tp > >::value >::type | std::swap (_Tp &__a, _Tp &__b) noexcept(/*conditional */) is_nothrow_move_assignable< _Tp >>
template<typename _Tp , size_t _Nm>
constexpr enable_if< __is_swappable< _Tp >::value >::type | std::swap (_Tp(&__a)[_Nm], _Tp(&__b)[_Nm]) noexcept(/*conditional */)
void | std::swap (any &__x, any &__y) noexcept
template<typename _Tp >
constexpr enable_if_t< is_move_constructible_v< _Tp > &&is_swappable_v< _Tp > > | std::swap (optional< _Tp > &__lhs, optional< _Tp > &__rhs) noexcept(noexcept(__lhs.swap(__rhs)))
template<typename... _Elements>
constexpr enable_if< __and_< __is_swappable< _Elements >... >::value >::type | std::swap (tuple< _Elements... > &__x, tuple< _Elements... > &__y) noexcept(noexcept(__x.swap(__y)))
template<typename... _Elements>
constexpr tuple< _Elements &... > | std::tie (_Elements &... __args) noexcept
template<typename... _Tpls, typename = typename enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>
constexpr auto | std::tuple_cat (_Tpls &&... __tpls) -> typename __tuple_cat_result< _Tpls... >::__type

## Variables

template<template< typename... > class _Trait, typename _Tp , typename _Tuple >
constexpr bool | std::__unpack_std_tuple
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool | std::__unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > & >
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool | std::__unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > >
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool | std::__unpack_std_tuple< _Trait, _Tp, tuple< _Up... > & >
template<template< typename... > class _Trait, typename _Tp , typename... _Up>
constexpr bool | std::__unpack_std_tuple< _Trait, _Tp, tuple< _Up... > >
constexpr _Swallow_assign | std::ignore
constexpr nullopt_t | std::nullopt
constexpr piecewise_construct_t | std::piecewise_construct
template<typename _Tp >
constexpr size_t | std::tuple_size_v
template<typename _ValueType >
_ValueType | std::any_cast (any &__any)
template<typename _ValueType >
_ValueType | std::any_cast (any &&__any)
template<typename _ValueType >
const _ValueType * | std::any_cast (const any *__any) noexcept
template<typename _ValueType >
_ValueType * | std::any_cast (any *__any) noexcept
template<typename _T1 , typename _T2 >
constexpr bool | operator== (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<typename _T1 , typename _T2 >
constexpr bool | operator< (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<typename _T1 , typename _T2 >
constexpr bool | operator!= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<typename _T1 , typename _T2 >
constexpr bool | operator> (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<typename _T1 , typename _T2 >
constexpr bool | operator<= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<typename _T1 , typename _T2 >
constexpr bool | operator>= (const pair< _T1, _T2 > &__x, const pair< _T1, _T2 > &__y)
template<typename _T1 , typename _T2 >
constexpr enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type | swap (pair< _T1, _T2 > &__x, pair< _T1, _T2 > &__y) noexcept(noexcept(__x.swap(__y)))

## Detailed Description

Components deemed generally useful. Includes pair, tuple, forward/move helpers, ratio, function object, metaprogramming and type traits, time, date, and memory functions.

## Function Documentation

## pair()

template<class _T1 , class _T2 >
template<typename... _Args1, typename... _Args2>

constexpr std::pair< _T1, _T2 >::pair | ( | piecewise_construct_t | ,
|  | tuple< _Args1... > | __first,
|  | tuple< _Args2... > | __second
| ) |  |

inline constexpr

"piecewise construction" using a tuple of arguments for each member.

Parameters

  __first | Arguments for the first member of the pair.
  __second | Arguments for the second member of the pair.

The elements of each tuple will be used as the constructor arguments for the data members of the pair.

Definition at line 1804 of file tuple.

## __addressof()

template<typename _Tp >

constexpr _Tp* std::__addressof | ( | _Tp & | __r | ) |

inline constexpr noexcept

Same as C++11 std::addressof.

Definition at line 49 of file move.h.

Referenced by std::_Destroy(), __gnu_debug::_Safe_sequence< _Sequence >::_M_transfer_from_if(), std::addressof(), std::list< _Tp, _Alloc >::merge(), std::sub_match< _BiIter >::operator<(), std::forward_list< _Tp, _Alloc >::operator=(), std::list< _Tp, _Alloc >::operator=(), std::sub_match< _BiIter >::operator==(), std::rethrow_if_nested(), and std::list< _Tp, _Alloc >::splice().

## __invoke()

template<typename _Callable , typename... _Args>

constexpr __invoke_result<_Callable, _Args...>::type std::__invoke | ( | _Callable && | __fn,
|  | _Args &&... | __args
| ) |  |

constexpr noexcept

Invoke a callable object.

Definition at line 90 of file invoke.h.

## addressof()

template<typename _Tp >

constexpr _Tp* std::addressof | ( | _Tp & | __r | ) |

inline constexpr noexcept

Returns the actual address of the object or function referenced by r, even in the presence of an overloaded operator&.

Parameters

  __r | Reference to an object or function.

Returns
  The actual address.

Definition at line 145 of file move.h.

References std::__addressof().

Referenced by std::pointer_traits< _Tp * >::pointer_to().

## any_cast() [1/5]

template<typename _ValueType >

_ValueType std::any_cast | ( | any && | __any | ) |

inline

Access the contained object.

Template Parameters

  _ValueType | A reference or CopyConstructible type.

Parameters

  __any | The object to access.

Returns
  The contained object.

Exceptions

  bad_any_cast | If `__any.type() != typeid(remove_reference_t<_ValueType>)`

Definition at line 500 of file any.

## any_cast() [2/5]

template<typename _ValueType >

_ValueType std::any_cast | ( | any & | __any | ) |

inline

Access the contained object.

Template Parameters

  _ValueType | A reference or CopyConstructible type.

Parameters

  __any | The object to access.

Returns
  The contained object.

Exceptions

  bad_any_cast | If `__any.type() != typeid(remove_reference_t<_ValueType>)`

Definition at line 486 of file any.

## any_cast() [3/5]

template<typename _ValueType >

_ValueType* std::any_cast | ( | any * | __any | ) |

inline noexcept

Access the contained object.

Template Parameters

  _ValueType | The type of the contained object.

Parameters

  __any | A pointer to the object to access.

Returns
  The address of the contained object if `__any != nullptr && __any.type() == typeid(_ValueType)` , otherwise a null pointer.

Definition at line 562 of file any.

## any_cast() [4/5]

template<typename _ValueType >

_ValueType std::any_cast | ( | const any & | __any | ) |

inline

Access the contained object.

Template Parameters

  _ValueType | A const-reference or CopyConstructible type.

Parameters

  __any | The object to access.

Returns
  The contained object.

Exceptions

  bad_any_cast | If `__any.type() != typeid(remove_reference_t<_ValueType>)`

Definition at line 460 of file any.

## any_cast() [5/5]

template<typename _ValueType >

const _ValueType* std::any_cast | ( | const any * | __any | ) |

inline noexcept

Access the contained object.

Template Parameters

  _ValueType | The type of the contained object.

Parameters

  __any | A pointer to the object to access.

Returns
  The address of the contained object if `__any != nullptr && __any.type() == typeid(_ValueType)` , otherwise a null pointer.

Definition at line 553 of file any.

## declval()

template<typename _Tp >

auto std::declval | ( |  | ) | -> decltype(__declval< _Tp >(0))

noexcept

Utility to simplify expressions used in unevaluated operands

Since
  C++11

Definition at line 2358 of file type_traits.

## forward() [1/2]

template<typename _Tp >

constexpr _Tp&& std::forward | ( | typename std::remove_reference< _Tp >::type && | __t | ) |

constexpr noexcept

Forward an rvalue.

Returns
  The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 89 of file move.h.

## forward() [2/2]

template<typename _Tp >

constexpr _Tp&& std::forward | ( | typename std::remove_reference< _Tp >::type & | __t | ) |

constexpr noexcept

Forward an lvalue.

Returns
  The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 77 of file move.h.

## forward_as_tuple()

template<typename... _Elements>

constexpr tuple<_Elements&&...> std::forward_as_tuple | ( | _Elements &&... | __args | ) |

constexpr noexcept

std::forward_as_tuple

Definition at line 1617 of file tuple.

Referenced by std::map< _Key, _Tp, _Compare, _Alloc >::insert_or_assign(), and std::map< _Key, _Tp, _Compare, _Alloc >::try_emplace().

## get() [1/8]

template<size_t __i, typename... _Elements>

constexpr const __tuple_element_t<__i, tuple<_Elements...> >&& std::get | ( | const tuple< _Elements... > && | __t | ) |

constexpr noexcept

Return a const rvalue reference to the ith element of a const tuple rvalue.

Definition at line 1414 of file tuple.

## get() [2/8]

template<size_t __i, typename... _Elements>

constexpr const __tuple_element_t<__i, tuple<_Elements...> >& std::get | ( | const tuple< _Elements... > & | __t | ) |

constexpr noexcept

Return a const reference to the ith element of a const tuple.

Definition at line 1399 of file tuple.

## get() [3/8]

template<typename _Tp , typename... _Types>

constexpr const _Tp&& std::get | ( | const tuple< _Types... > && | __t | ) |

constexpr noexcept

Return a const reference to the unique element of type _Tp of a const tuple rvalue.

Definition at line 1483 of file tuple.

## get() [4/8]

template<typename _Tp , typename... _Types>

constexpr const _Tp& std::get | ( | const tuple< _Types... > & | __t | ) |

constexpr noexcept

Return a const reference to the unique element of type _Tp of a tuple.

Definition at line 1471 of file tuple.

## get() [5/8]

template<size_t __i, typename... _Elements>

constexpr __tuple_element_t<__i, tuple<_Elements...> >&& std::get | ( | tuple< _Elements... > && | __t | ) |

constexpr noexcept

Return an rvalue reference to the ith element of a tuple rvalue.

Definition at line 1405 of file tuple.

## get() [6/8]

template<size_t __i, typename... _Elements>

constexpr __tuple_element_t<__i, tuple<_Elements...> >& std::get | ( | tuple< _Elements... > & | __t | ) |

constexpr noexcept

Return a reference to the ith element of a tuple.

Definition at line 1393 of file tuple.

## get() [7/8]

template<typename _Tp , typename... _Types>

constexpr _Tp&& std::get | ( | tuple< _Types... > && | __t | ) |

constexpr noexcept

Return a reference to the unique element of type _Tp of a tuple rvalue.

Definition at line 1460 of file tuple.

## get() [8/8]

template<typename _Tp , typename... _Types>

constexpr _Tp& std::get | ( | tuple< _Types... > & | __t | ) |

constexpr noexcept

Return a reference to the unique element of type _Tp of a tuple.

Definition at line 1449 of file tuple.

## make_any() [1/2]

template<typename _Tp , typename... _Args>

enable_if_t<is_constructible_v<any, in_place_type_t<_Tp>, _Args...>, any> std::make_any | ( | _Args &&... | __args | ) |

inline

Create an `any` holding a `_Tp` constructed from `__args...`.

Definition at line 434 of file any.

## make_any() [2/2]

template<typename _Tp , typename _Up , typename... _Args>

enable_if_t<is_constructible_v<any, in_place_type_t<_Tp>, initializer_list<_Up>&, _Args...>, any> std::make_any | ( | initializer_list< _Up > | __il,
|  | _Args &&... | __args
| ) |  |

inline

Create an `any` holding a `_Tp` constructed from `__il` and `__args...`.

Definition at line 444 of file any.

## make_pair()

template<typename _T1 , typename _T2 >

constexpr pair< typename __decay_and_strip< _T1 >::__type, typename __decay_and_strip< _T2 >::__type > make_pair | ( | _T1 && | __x,
|  | _T2 && | __y
| ) |  |

related

A convenience wrapper for creating a pair from two objects.

Parameters

  __x | The first object.
  __y | The second object.

Returns
  A newly-constructed pair<> object of the appropriate type.

The C++98 standard says the objects are passed by reference-to-const, but C++03 says they are passed by value (this was LWG issue #181).

Since C++11 they have been passed by forwarding reference and then forwarded to the new members of the pair. To create a pair with a member of reference type, pass a `reference_wrapper` to this function.

Definition at line 567 of file stl_pair.h.

## move()

template<typename _Tp >

constexpr std::remove_reference<_Tp>::type&& std::move | ( | _Tp && | __t | ) |

constexpr noexcept

Convert a value to an rvalue.

Parameters

  __t | A thing of arbitrary type.

Returns
  The parameter cast to an rvalue-reference to allow moving it.

Definition at line 104 of file move.h.

Referenced by std::unique_ptr< _Tp, _Dp >::~unique_ptr(), std::basic_regex< _Ch_type, _Rx_traits >::assign(), std::shared_ptr< _Tp >::atomic_compare_exchange_strong_explicit(), std::for_each_n(), std::deque< _Tp, _Alloc >::insert(), std::list< _Tp, _Alloc >::insert(), std::vector< _Tp, _Alloc >::insert(), std::map< _Key, _Tp, _Compare, _Alloc >::insert(), std::multiset< _Key, _Compare, _Alloc >::insert(), std::set< _Key, _Compare, _Alloc >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::insert(), std::multimap< _Key, _Tp, _Compare, _Alloc >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >::insert(), std::unordered_set< _Value, _Hash, _Pred, _Alloc >::insert(), std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert(), std::forward_list< _Tp, _Alloc >::merge(), std::move_if_noexcept(), std::deque< _Tp, _Alloc >::operator=(), std::forward_list< _Tp, _Alloc >::operator=(), std::function< _Res(_ArgTypes...)>::operator=(), std::list< _Tp, _Alloc >::operator=(), std::vector< _Tp, _Alloc >::operator=(), std::unordered_map< _Key, _Tp, _Hash, _Pred, _Alloc >::operator[](), std::unique_ptr< _Tp[], _Dp >::reset(), std::unique_ptr< _Tp, _Dp >::reset(), and std::list< _Tp, _Alloc >::splice().

## move_if_noexcept()

template<typename _Tp >

constexpr conditional<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>::type std::move_if_noexcept | ( | _Tp & | __x | ) |

constexpr noexcept

Conditionally convert a value to an rvalue.

Parameters

  __x | A thing of arbitrary type.

Returns
  The parameter, possibly cast to an rvalue-reference.

Same as std::move unless the type's move constructor could throw and the type is copyable, in which case an lvalue-reference is returned instead.

Definition at line 125 of file move.h.

References std::move().

## operator!=()

template<typename _T1 , typename _T2 >

constexpr bool operator!= | ( | const pair< _T1, _T2 > & | __x,
|  | const pair< _T1, _T2 > & | __y
| ) |  |

related

Uses `operator==` to find the result.

Definition at line 496 of file stl_pair.h.

## operator<()

template<typename _T1 , typename _T2 >

constexpr bool operator< | ( | const pair< _T1, _T2 > & | __x,
|  | const pair< _T1, _T2 > & | __y
| ) |  |

related

Defines a lexicographical order for pairs.

For two pairs of the same type, `P` is ordered before `Q` if `P.first` is less than `Q.first`, or if `P.first` and `Q.first` are equivalent (neither is less than the other) and `P.second` is less than `Q.second`.

Definition at line 488 of file stl_pair.h.

References std::pair< _T1, _T2 >::first, and std::pair< _T1, _T2 >::second.

## operator<=()

template<typename _T1 , typename _T2 >

constexpr bool operator<= | ( | const pair< _T1, _T2 > & | __x,
|  | const pair< _T1, _T2 > & | __y
| ) |  |

related

Uses `operator<` to find the result.

Definition at line 507 of file stl_pair.h.

## operator==()

template<typename _T1 , typename _T2 >

constexpr bool operator== | ( | const pair< _T1, _T2 > & | __x,
|  | const pair< _T1, _T2 > & | __y
| ) |  |

related

Two pairs of the same type are equal iff their members are equal.

Definition at line 466 of file stl_pair.h.

References std::pair< _T1, _T2 >::first, and std::pair< _T1, _T2 >::second.

## operator>()

template<typename _T1 , typename _T2 >

constexpr bool operator> | ( | const pair< _T1, _T2 > & | __x,
|  | const pair< _T1, _T2 > & | __y
| ) |  |

related

Uses `operator<` to find the result.

Definition at line 502 of file stl_pair.h.

## operator>=()

template<typename _T1 , typename _T2 >

constexpr bool operator>= | ( | const pair< _T1, _T2 > & | __x,
|  | const pair< _T1, _T2 > & | __y
| ) |  |

related

Uses `operator<` to find the result.

Definition at line 514 of file stl_pair.h.

## swap() [1/5]

template<typename _Tp >

constexpr enable_if<__and_<__not_<__is_tuple_like<_Tp> >, is_move_constructible<_Tp>, is_move_assignable<_Tp> >::value>::type std::swap | ( | _Tp & | __a,
|  | _Tp & | __b
| ) |  |

inline constexpr noexcept

Swaps two values.

Parameters

  __a | A thing of arbitrary type.
  __b | Another thing of arbitrary type.

Returns
  Nothing.

Definition at line 196 of file move.h.

## swap() [2/5]

template<typename _Tp , size_t _Nm>

constexpr enable_if<__is_swappable<_Tp>::value>::type std::swap | ( | _Tp(&) | __a[_Nm],
|  | _Tp(&) | __b[_Nm]
| ) |  |

inline constexpr noexcept

Swap the contents of two arrays.

Definition at line 220 of file move.h.

References std::swap().

## swap() [3/5]

void std::swap | ( | any & | __x,
|  | any & | __y
| ) |  |

inline noexcept

Exchange the states of two `any` objects.

Definition at line 428 of file any.

Referenced by __gnu_parallel::_LoserTree< __stable, _Tp, _Compare >::__delete_min_insert(), __gnu_parallel::_LoserTree< false, _Tp, _Compare >::__delete_min_insert(), std::regex_traits< _Ch_type >::imbue(), std::basic_regex< _Ch_type, _Rx_traits >::imbue(), std::function< _Res(_ArgTypes...)>::operator=(), std::swap(), std::basic_regex< _Ch_type, _Rx_traits >::swap(), std::forward_list< _Tp, _Alloc >::swap(), std::function< _Res(_ArgTypes...)>::swap(), std::match_results< _Bi_iter, _Alloc >::swap(), and std::pair< _T1, _T2 >::swap().

## swap() [4/5]

template<typename _T1 , typename _T2 >

constexpr enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type swap | ( | pair< _T1, _T2 > & | __x,
|  | pair< _T1, _T2 > & | __y
| ) |  |

related

Swap overload for pairs. Calls std::pair::swap().

Note
  This std::swap overload is not declared in C++03 mode, which has performance implications, e.g. see https://gcc.gnu.org/PR38466

Definition at line 533 of file stl_pair.h.

References std::pair< _T1, _T2 >::swap().

## swap() [5/5]

template<typename... _Elements>

constexpr enable_if<__and_<__is_swappable<_Elements>...>::value >::type std::swap | ( | tuple< _Elements... > & | __x,
|  | tuple< _Elements... > & | __y
| ) |  |

inline constexpr delete noexcept

swap

Definition at line 1760 of file tuple.

## tie()

template<typename... _Elements>

constexpr tuple<_Elements&...> std::tie | ( | _Elements &... | __args | ) |

constexpr noexcept

tie

Definition at line 1746 of file tuple.

Referenced by std::basic_ios< _CharT, _Traits >::copyfmt().

## tuple_cat()

template<typename... _Tpls, typename = typename enable_if<__and_<__is_tuple_like<_Tpls>...>::value>::type>

constexpr auto std::tuple_cat | ( | _Tpls &&... | __tpls | ) | -> typename __tuple_cat_result<_Tpls...>::__type

constexpr

tuple_cat

Definition at line 1732 of file tuple.

## Variable Documentation

## nullopt

constexpr nullopt_t std::nullopt

inline constexpr

Tag to disengage optional objects.

Definition at line 82 of file optional.

## piecewise_construct

constexpr piecewise_construct_t std::piecewise_construct

inline constexpr

Tag for piecewise construction of std::pair objects.

Definition at line 83 of file stl_pair.h.

Referenced by std::map< _Key, _Tp, _Compare, _Alloc >::insert_or_assign(), and std::map< _Key, _Tp, _Compare, _Alloc >::try_emplace().