Utilities
Collaboration diagram for Utilities:

## Topics

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

## Classes

struct | std::_Optional_base< _Tp, bool, bool >
struct | std::_Tuple_impl< _Idx, _Elements >
struct | std::_Tuple_impl< _Idx, _Head, _Tail... >
class | std::any
struct | std::array< _Tp, _Nm >
class | std::bad_any_cast
class | std::bad_optional_access
class | std::bitset< _Nb >
struct | std::nullopt_t
class | std::optional< _Tp >
struct | std::pair< _T1, _T2 >
struct | std::piecewise_construct_t
class | std::tuple< _Elements >
class | std::tuple< _T1, _T2 >
struct | std::tuple_element< __i, tuple< _Types... > >
struct | std::tuple_size< tuple< _Elements... > >
struct | std::type_index
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
template<typename _Tp, typename _Up>
using | std::__converts_from_optional
template<typename _Tp>
using | std::__empty_not_final
template<typename _Tp, typename _Up>
using | std::__optional_eq_t
template<typename _Tp, typename _Up>
using | std::__optional_ge_t
template<typename _Tp, typename _Up>
using | std::__optional_gt_t
template<typename _Tp, typename _Up>
using | std::__optional_le_t
template<typename _Tp, typename _Up>
using | std::__optional_lt_t
template<typename _Tp, typename _Up>
using | std::__optional_ne_t
template<typename _Tp>
using | std::__optional_relop_t

## 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<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_external< _Tp >::_S_manage (_Op __which, const any *__anyp, _Arg *__arg)
static void | std::any::_Manager_internal< _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 _Int, typename _Tp, size_t _Nm>
constexpr _Tp && | std::get (array< _Tp, _Nm > &&) noexcept
template<size_t _Int, typename _Tp, size_t _Nm>
constexpr _Tp & | std::get (array< _Tp, _Nm > &) noexcept
template<size_t _Int, typename _Tp, size_t _Nm>
constexpr const _Tp && | std::get (const array< _Tp, _Nm > &&) noexcept
template<size_t _Int, typename _Tp, size_t _Nm>
constexpr const _Tp & | std::get (const array< _Tp, _Nm > &) 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 > | std::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_t< __move_if_noexcept_cond< _Tp >::value, const _Tp &, _Tp && > | 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... _UTypes>
| std::tuple (_UTypes...) -> tuple< _UTypes... >
template<typename _Alloc, typename... _UTypes>
| std::tuple (allocator_arg_t, _Alloc, _UTypes...) -> tuple< _UTypes... >
template<typename _Alloc, typename _T1, typename _T2>
| std::tuple (allocator_arg_t, _Alloc, pair< _T1, _T2 >) -> tuple< _T1, _T2 >
template<typename _Alloc, typename... _UTypes>
| std::tuple (allocator_arg_t, _Alloc, tuple< _UTypes... >) -> tuple< _UTypes... >
template<typename _T1, typename _T2>
| std::tuple (pair< _T1, _T2 >) -> tuple< _T1, _T2 >
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<typename _Tp>
constexpr bool | std::__is_optional_v
template<typename _Tp>
constexpr bool | std::__is_optional_v< optional< _Tp > >
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... _Types>
constexpr size_t | std::tuple_size_v< const tuple< _Types... > >
template<typename... _Types>
constexpr size_t | std::tuple_size_v< tuple< _Types... > >
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>
| pair (_T1, _T2) -> pair< _T1, _T2 >
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)))
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)))
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)

## Detailed Description

Basic function and class templates used with the rest of the library. Includes pair, swap, forward/move helpers, declval, integer_sequence.

## Macro Definition Documentation

## __cpp_lib_addressof_constexpr

#define __cpp_lib_addressof_constexpr

Definition at line 126 of file move.h.

## __cpp_lib_any

#define __cpp_lib_any

Definition at line 70 of file any.

## __cpp_lib_apply

#define __cpp_lib_apply

Definition at line 2295 of file tuple.

## __cpp_lib_make_from_tuple

#define __cpp_lib_make_from_tuple

Definition at line 2317 of file tuple.

## __cpp_lib_optional

#define __cpp_lib_optional

Definition at line 66 of file optional.

## __cpp_lib_tuples_by_type

#define __cpp_lib_tuples_by_type

Definition at line 1838 of file tuple.

## Typedef Documentation

## __assigns_from_optional

template<typename _Tp, typename _Up>

using std::__assigns_from_optional

Definition at line 697 of file optional.

## __converts_from_optional

template<typename _Tp, typename _Up>

using std::__converts_from_optional

Definition at line 686 of file optional.

## __empty_not_final

template<typename _Tp>

using std::__empty_not_final

Definition at line 69 of file tuple.

## __optional_eq_t

template<typename _Tp, typename _Up>

using std::__optional_eq_t

Definition at line 1204 of file optional.

## __optional_ge_t

template<typename _Tp, typename _Up>

using std::__optional_ge_t

Definition at line 1229 of file optional.

## __optional_gt_t

template<typename _Tp, typename _Up>

using std::__optional_gt_t

Definition at line 1219 of file optional.

## __optional_le_t

template<typename _Tp, typename _Up>

using std::__optional_le_t

Definition at line 1224 of file optional.

## __optional_lt_t

template<typename _Tp, typename _Up>

using std::__optional_lt_t

Definition at line 1214 of file optional.

## __optional_ne_t

template<typename _Tp, typename _Up>

using std::__optional_ne_t

Definition at line 1209 of file optional.

## __optional_relop_t

template<typename _Tp>

using std::__optional_relop_t

Definition at line 1200 of file optional.

## Function Documentation

## pair() [1/2]

template<typename _T1, typename _T2>

pair | ( | _T1 | ,
|  | _T2 | )->pair< _T1, _T2 >

related

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

## pair() [2/2]

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

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 2251 of file tuple.

References pair().

## __addressof()

template<typename _Tp>

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

inline constexpr noexcept

Same as C++11 std::addressof.

Definition at line 51 of file move.h.

Referenced by std::back_insert_iterator< _Container >::back_insert_iterator(), std::front_insert_iterator< _Container >::front_insert_iterator(), std::insert_iterator< _Container >::insert_iterator(), std::istream_iterator< _Tp, _CharT, _Traits, _Dist >::istream_iterator(), std::ostream_iterator< _Tp, _CharT, _Traits >::ostream_iterator(), std::ostream_iterator< _Tp, _CharT, _Traits >::ostream_iterator(), __gnu_debug::_Safe_sequence< _Sequence >::_M_transfer_from_if(), addressof(), begin(), begin(), std::basic_ios< _CharT, _Traits >::copyfmt(), end(), end(), std::forward_list< _Tp, _Alloc >::merge(), std::list< _Tp, _Alloc >::merge(), std::list< _Tp, _Alloc >::merge(), std::sub_match< const char * >::operator<(), std::sub_match< const char * >::operator<(), __gnu_debug::_Safe_iterator< _Base_iterator, map >::operator=(), __gnu_debug::_Safe_local_iterator< _OtherIterator, _Sequence >::operator=(), std::basic_string< _CharT >::operator=(), std::deque< _Tp, _Alloc >::operator=(), std::forward_list< _Tp, _Alloc >::operator=(), std::list< _Tp, _Alloc >::operator=(), std::vector< _Tp, _Alloc >::operator=(), std::sub_match< const char * >::operator==(), std::sub_match< const char * >::operator==(), std::list< _Tp, polymorphic_allocator< _Tp > >::splice(), and std::list< _Tp, polymorphic_allocator< _Tp > >::splice().

## __apply_impl()

template<typename _Fn, typename _Tuple, size_t... _Idx>

decltype(auto) std::__apply_impl | ( | _Fn && | __f,
|  | _Tuple && | __t,
|  | index_sequence< _Idx... > | )

constexpr

Definition at line 2299 of file tuple.

## __exchange()

template<typename _Tp, typename _Up = _Tp>

_Tp std::__exchange | ( | _Tp & | __obj,
|  | _Up && | __new_val )

inline constexpr

Definition at line 150 of file move.h.

## __get_helper() [1/2]

template<size_t __i, typename _Head, typename... _Tail>

_Head & std::__get_helper | ( | _Tuple_impl< __i, _Head, _Tail... > & | __t | ) |

constexpr noexcept

Definition at line 1786 of file tuple.

## __get_helper() [2/2]

template<size_t __i, typename _Head, typename... _Tail>

const _Head & std::__get_helper | ( | const _Tuple_impl< __i, _Head, _Tail... > & | __t | ) |

constexpr noexcept

Definition at line 1791 of file tuple.

## __invfwd()

template<typename _Tp, typename _Up = typename __inv_unwrap<_Tp>::type>

_Up && std::__invfwd | ( | typename remove_reference< _Tp >::type & | __t | ) |

constexpr noexcept

Definition at line 55 of file invoke.h.

## __invoke()

template<typename _Callable, typename... _Args>

__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.

References forward().

Referenced by std::once_flag::call_once, and invoke().

## __invoke_impl() [1/5]

template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>

_Res std::__invoke_impl | ( | __invoke_memfun_deref | ,
|  | _MemFun && | __f,
|  | _Tp && | __t,
|  | _Args &&... | __args )

constexpr

Definition at line 71 of file invoke.h.

## __invoke_impl() [2/5]

template<typename _Res, typename _MemFun, typename _Tp, typename... _Args>

_Res std::__invoke_impl | ( | __invoke_memfun_ref | ,
|  | _MemFun && | __f,
|  | _Tp && | __t,
|  | _Args &&... | __args )

constexpr

Definition at line 65 of file invoke.h.

## __invoke_impl() [3/5]

template<typename _Res, typename _MemPtr, typename _Tp>

_Res std::__invoke_impl | ( | __invoke_memobj_deref | ,
|  | _MemPtr && | __f,
|  | _Tp && | __t )

constexpr

Definition at line 84 of file invoke.h.

## __invoke_impl() [4/5]

template<typename _Res, typename _MemPtr, typename _Tp>

_Res std::__invoke_impl | ( | __invoke_memobj_ref | ,
|  | _MemPtr && | __f,
|  | _Tp && | __t )

constexpr

Definition at line 79 of file invoke.h.

## __invoke_impl() [5/5]

template<typename _Res, typename _Fn, typename... _Args>

_Res std::__invoke_impl | ( | __invoke_other | ,
|  | _Fn && | __f,
|  | _Args &&... | __args )

constexpr

Definition at line 60 of file invoke.h.

## __invoke_r()

template<typename _Res, typename _Callable, typename... _Args>

enable_if_t< is_invocable_r_v< _Res, _Callable, _Args... >, _Res > std::__invoke_r | ( | _Callable && | __fn,
|  | _Args &&... | __args )

constexpr noexcept

Definition at line 104 of file invoke.h.

## __make_from_tuple_impl()

template<typename _Tp, typename _Tuple, size_t... _Idx>

_Tp std::__make_from_tuple_impl | ( | _Tuple && | __t,
|  | index_sequence< _Idx... > | )

constexpr

Definition at line 2321 of file tuple.

## __throw_bad_any_cast()

void std::__throw_bad_any_cast | ( |  | ) |

inline

Definition at line 61 of file any.

## __throw_bad_optional_access()

void std::__throw_bad_optional_access | ( |  | ) |

inline

Definition at line 110 of file optional.

## _S_manage() [1/2]

template<typename _Tp>

void std::any::_Manager_external< _Tp >::_S_manage | ( | _Op | __which,
|  | const any * | __anyp,
|  | _Arg * | __arg )

static

Definition at line 608 of file any.

## _S_manage() [2/2]

template<typename _Tp>

void std::any::_Manager_internal< _Tp >::_S_manage | ( | _Op | __which,
|  | const any * | __anyp,
|  | _Arg * | __arg )

static

Definition at line 574 of file any.

## addressof()

template<typename _Tp>

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

inline nodiscard 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 138 of file move.h.

References __addressof().

## 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 501 of file any.

References any_cast(), and move().

## 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 487 of file any.

References any_cast().

## 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 563 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 461 of file any.

References any_cast().

Referenced by any_cast(), any_cast(), and any_cast().

## 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 554 of file any.

## apply()

template<typename _Fn, typename _Tuple>

decltype(auto) std::apply | ( | _Fn && | __f,
|  | _Tuple && | __t )

constexpr noexcept

Definition at line 2307 of file tuple.

## 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 2384 of file type_traits.

Referenced by std::vector< _Tp, polymorphic_allocator< _Tp > >::vector(), and std::unique_ptr< _State >::operator*().

## forward() [1/2]

template<typename _Tp>

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

nodiscard constexpr noexcept

Forward an rvalue.

Returns
  The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 82 of file move.h.

## forward() [2/2]

template<typename _Tp>

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

nodiscard constexpr noexcept

Forward an lvalue.

Returns
  The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 70 of file move.h.

Referenced by std::any::any(), std::any::any(), std::any::any(), std::experimental::fundamentals_v1::any::any(), std::function< _Res(_ArgTypes...)>::function(), std::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>::move_only_function(), std::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>::move_only_function(), std::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>::move_only_function(), std::unique_ptr< _State >::unique_ptr(), __invoke(), _Construct(), std::list< _Tp, polymorphic_allocator< _Tp > >::_M_create_node(), std::deque< _Tp, _Alloc >::_M_push_back_aux(), std::deque< _Tp, _Alloc >::_M_push_front_aux(), std::shared_ptr< _State_base >::allocate_shared(), async(), async(), bind(), bind_front(), std::once_flag::call_once, std::allocator_traits< _OuterAlloc >::construct(), std::allocator_traits< allocator< _Tp > >::construct(), std::allocator_traits< allocator< void > >::construct(), std::allocator_traits< pmr::polymorphic_allocator< _Tp > >::construct(), std::any::emplace(), std::any::emplace(), std::deque< _Tp, _Alloc >::emplace(), std::list< _Tp, _Alloc >::emplace(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace(), std::multiset< _Key, _Cmp, polymorphic_allocator< _Key > >::emplace(), std::set< _Key, _Cmp, polymorphic_allocator< _Key > >::emplace(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace(), std::unordered_multiset< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::emplace(), std::unordered_set< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::emplace(), std::vector< _Tp, polymorphic_allocator< _Tp > >::emplace(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::emplace_after(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::emplace_front(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace_hint(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace_hint(), std::multiset< _Key, _Cmp, polymorphic_allocator< _Key > >::emplace_hint(), std::set< _Key, _Cmp, polymorphic_allocator< _Key > >::emplace_hint(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace_hint(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::emplace_hint(), std::unordered_multiset< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::emplace_hint(), std::unordered_set< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::emplace_hint(), exchange(), forward_as_tuple(), get(), get(), get(), get(), get(), get(), get(), get(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), invoke(), make_any(), make_any(), std::experimental::make_array(), std::experimental::make_ostream_joiner(), make_pair(), std::shared_ptr< _State_base >::make_shared(), make_tuple(), std::unique_ptr< _State >::make_unique(), std::experimental::not_fn(), not_fn(), std::function< _Res(_ArgTypes...)>::operator()(), std::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>::operator()(), std::any::operator=(), std::experimental::fundamentals_v1::any::operator=(), std::function< _Res(_ArgTypes...)>::operator=(), std::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>::operator=(), std::unique_ptr< _State >::operator=(), std::unique_ptr< _Tp[], _Dp >::operator=(), operator>>(), std::experimental::sample(), sample(), throw_with_nested(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace(), and tuple_cat().

## forward_as_tuple()

template<typename... _Elements>

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

constexpr noexcept

Create a tuple of lvalue or rvalue references to the arguments.

Definition at line 2012 of file tuple.

References forward().

Referenced by std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace(), and std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace().

## get() [1/12]

template<size_t _Int, typename _Tp, size_t _Nm>

_Tp && std::get | ( | array< _Tp, _Nm > && | __arr | ) |

constexpr noexcept

Definition at line 393 of file array.

## get() [2/12]

template<size_t _Int, typename _Tp, size_t _Nm>

_Tp & std::get | ( | array< _Tp, _Nm > & | __arr | ) |

constexpr noexcept

Definition at line 384 of file array.

## get() [3/12]

template<size_t _Int, typename _Tp, size_t _Nm>

const _Tp && std::get | ( | const array< _Tp, _Nm > && | __arr | ) |

constexpr noexcept

Definition at line 411 of file array.

## get() [4/12]

template<size_t _Int, typename _Tp, size_t _Nm>

const _Tp & std::get | ( | const array< _Tp, _Nm > & | __arr | ) |

constexpr noexcept

Definition at line 402 of file array.

## get() [5/12]

template<size_t __i, typename... _Elements>

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 1823 of file tuple.

References forward().

## get() [6/12]

template<size_t __i, typename... _Elements>

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 1808 of file tuple.

## get() [7/12]

template<typename _Tp, typename... _Types>

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 1877 of file tuple.

References forward().

## get() [8/12]

template<typename _Tp, typename... _Types>

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 1865 of file tuple.

## get() [9/12]

template<size_t __i, typename... _Elements>

__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 1814 of file tuple.

References forward().

## get() [10/12]

template<size_t __i, typename... _Elements>

__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 1802 of file tuple.

## get() [11/12]

template<typename _Tp, typename... _Types>

_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 1854 of file tuple.

References forward().

## get() [12/12]

template<typename _Tp, typename... _Types>

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

constexpr noexcept

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

Definition at line 1843 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 435 of file any.

References forward().

## 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 445 of file any.

References forward().

## make_from_tuple()

template<typename _Tp, typename _Tuple>

_Tp std::make_from_tuple | ( | _Tuple && | __t | ) |

constexpr noexcept

Definition at line 2326 of file tuple.

## make_optional() [1/3]

template<typename _Tp, typename... _Args>

enable_if_t< is_constructible_v< _Tp, _Args... >, optional< _Tp > > std::make_optional | ( | _Args &&... | __args | ) |

constexpr noexcept

Definition at line 1470 of file optional.

## make_optional() [2/3]

template<typename _Tp>

enable_if_t< is_constructible_v< decay_t< _Tp >, _Tp >, optional< decay_t< _Tp > > > std::make_optional | ( | _Tp && | __t | ) |

constexpr noexcept

Definition at line 1462 of file optional.

## make_optional() [3/3]

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

enable_if_t< is_constructible_v< _Tp, initializer_list< _Up > &, _Args... >, optional< _Tp > > std::make_optional | ( | initializer_list< _Up > | __il,
|  | _Args &&... | __args )

constexpr noexcept

Definition at line 1478 of file optional.

## make_pair()

template<typename _T1, typename _T2>

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

constexpr

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 922 of file stl_pair.h.

References forward().

Referenced by __gnu_parallel::__find_template(), __gen_two_uniform_ints(), __gnu_debug::__get_distance(), __gnu_parallel::__parallel_merge_advance(), __gnu_parallel::__parallel_sort_qsb(), __gnu_parallel::__qsb_local_sort_with_helping(), __gnu_parallel::__adjacent_find_selector::_M_sequential_algorithm(), __gnu_parallel::__find_first_of_selector< _FIterator >::_M_sequential_algorithm(), __gnu_parallel::__find_if_selector::_M_sequential_algorithm(), __gnu_parallel::multiseq_partition(), __gnu_parallel::multiseq_selection(), __gnu_parallel::parallel_multiway_merge(), __gnu_parallel::parallel_sort_mwms_pu(), and __gnu_pbds::detail::pat_trie_base::_Node_citer< node, leaf, head, inode, const_iterator, iterator, _Alloc >::valid_prefix().

## make_tuple()

template<typename... _Elements>

tuple< typename __decay_and_strip< _Elements >::__type... > std::make_tuple | ( | _Elements &&... | __args | ) |

constexpr

Create a tuple containing copies of the arguments.

Definition at line 2000 of file tuple.

References forward().

## move()

template<typename _Tp>

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

nodiscard 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 97 of file move.h.

Referenced by __gnu_cxx::__versa_string< char >::__versa_string(), std::basic_string< _CharT >::basic_string(), std::deque< _Tp, polymorphic_allocator< _Tp > >::deque(), std::discard_block_engine< ranlux24_base, 223, 23 >::discard_block_engine(), std::tr2::dynamic_bitset< _WordT, _Alloc >::dynamic_bitset(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::forward_list(), std::future< _Res >::future(), std::future< _Res & >::future(), std::future< void >::future(), std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType >::independent_bits_engine(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::map(), std::match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > >< const char * >::match_results(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::multimap(), std::multiset< _Key, _Cmp, polymorphic_allocator< _Key > >::multiset(), std::set< _Key, _Cmp, polymorphic_allocator< _Key > >::set(), std::shared_future< _Res >::shared_future(), std::shared_future< _Res >::shared_future(), std::shared_future< _Res & >::shared_future(), std::shared_future< _Res & >::shared_future(), std::shared_future< void >::shared_future(), std::shared_future< void >::shared_future(), std::shared_ptr< _State_base >::shared_ptr(), std::shared_ptr< _State_base >::shared_ptr(), std::shared_ptr< _State_base >::shared_ptr(), std::shared_ptr< _State_base >::shared_ptr(), std::shared_ptr< _State_base >::shared_ptr(), std::shared_ptr< _State_base >::shared_ptr(), std::shared_ptr< _State_base >::shared_ptr(), std::shuffle_order_engine< minstd_rand0, 256 >::shuffle_order_engine(), std::unique_ptr< _State >::unique_ptr(), std::unique_ptr< _Tp[], _Dp >::unique_ptr(), std::vector< _Tp, polymorphic_allocator< _Tp > >::vector(), std::unique_ptr< _State >::~unique_ptr(), any_cast(), std::experimental::any_cast(), std::basic_regex< char >::assign(), std::basic_string< _CharT >::assign(), async(), atomic_compare_exchange_strong(), atomic_compare_exchange_strong(), atomic_compare_exchange_strong_explicit(), atomic_compare_exchange_strong_explicit(), atomic_compare_exchange_weak(), atomic_compare_exchange_weak(), atomic_compare_exchange_weak_explicit(), atomic_compare_exchange_weak_explicit(), atomic_exchange(), atomic_exchange(), atomic_store(), atomic_store(), std::shared_ptr< _State_base >::const_pointer_cast(), std::shared_ptr< _State_base >::dynamic_pointer_cast(), exclusive_scan(), exclusive_scan(), for_each_n(), std::future< _Res >::get(), get(), get(), inclusive_scan(), std::deque< _Tp, polymorphic_allocator< _Tp > >::insert(), std::list< _Tp, polymorphic_allocator< _Tp > >::insert(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multimap< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::multiset< _Key, _Cmp, polymorphic_allocator< _Key > >::insert(), std::multiset< _Key, _Cmp, polymorphic_allocator< _Key > >::insert(), std::set< _Key, _Cmp, polymorphic_allocator< _Key > >::insert(), std::set< _Key, _Cmp, polymorphic_allocator< _Key > >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::insert(), std::unordered_multiset< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_multiset< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_multiset< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_multiset< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_set< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_set< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_set< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::unordered_set< _Key, _Hash, _Pred, polymorphic_allocator< _Key > >::insert(), std::vector< _Tp, _Alloc >::insert(), std::vector< _Tp, polymorphic_allocator< _Tp > >::insert(), std::experimental::make_boyer_moore_horspool_searcher(), std::experimental::make_boyer_moore_searcher(), std::forward_list< _Tp, _Alloc >::merge(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::merge(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::merge(), std::list< _Tp, polymorphic_allocator< _Tp > >::merge(), std::list< _Tp, polymorphic_allocator< _Tp > >::merge(), move_if_noexcept(), std::tr2::dynamic_bitset< _WordT, _Alloc >::operator&=(), std::chrono::operator<<(), std::deque< _Tp, polymorphic_allocator< _Tp > >::operator=(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::operator=(), std::function< _Res(_ArgTypes...)>::operator=(), std::list< _Tp, polymorphic_allocator< _Tp > >::operator=(), std::vector< _Tp, polymorphic_allocator< _Tp > >::operator=(), std::filesystem::path::operator>>, operator>>(), std::unordered_map< _Key, _Tp, _Hash, _Pred, polymorphic_allocator< pair< const _Key, _Tp > > >::operator[](), reduce(), std::shared_ptr< _State_base >::reinterpret_pointer_cast(), std::unique_ptr< _State >::reset(), std::unique_ptr< _Tp[], _Dp >::reset(), std::list< _Tp, polymorphic_allocator< _Tp > >::splice(), std::list< _Tp, polymorphic_allocator< _Tp > >::splice(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::splice_after(), std::shared_ptr< _State_base >::static_pointer_cast(), transform_exclusive_scan(), transform_inclusive_scan(), and transform_reduce().

## move_if_noexcept()

template<typename _Tp>

__conditional_t< __move_if_noexcept_cond< _Tp >::value, const _Tp &, _Tp && > std::move_if_noexcept | ( | _Tp & | __x | ) |

nodiscard 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 118 of file move.h.

References move().

## operator!=() [1/8]

template<typename _T1, typename _T2>

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

related

Uses `operator==` to find the result.

Definition at line 842 of file stl_pair.h.

## operator!=() [2/8]

template<typename _Tp, typename _Up>

auto std::operator!= | ( | const _Up & | __lhs,
|  | const optional< _Tp > & | __rhs )->__optional_ne_t< _Up, _Tp >

constexpr

Definition at line 1382 of file optional.

## operator!=() [3/8]

template<typename _Tp, typename _Up>

auto std::operator!= | ( | const optional< _Tp > & | __lhs,
|  | const _Up & | __rhs )->__optional_ne_t< _Tp, _Up >

constexpr

Definition at line 1376 of file optional.

## operator!=() [4/8]

template<typename _Tp, typename _Up>

auto std::operator!= | ( | const optional< _Tp > & | __lhs,
|  | const optional< _Up > & | __rhs )->__optional_ne_t< _Tp, _Up >

constexpr

Definition at line 1245 of file optional.

## operator!=() [5/8]

template<typename _Tp>

bool std::operator!= | ( | const optional< _Tp > & | __lhs,
|  | nullopt_t | )

constexpr noexcept

Definition at line 1312 of file optional.

## operator!=() [6/8]

template<typename... _TElements, typename... _UElements>

bool std::operator!= | ( | const tuple< _TElements... > & | __t,
|  | const tuple< _UElements... > & | __u )

constexpr

Definition at line 1973 of file tuple.

## operator!=() [7/8]

template<typename _Tp>

bool std::operator!= | ( | nullopt_t | ,
|  | const optional< _Tp > & | __rhs )

constexpr noexcept

Definition at line 1317 of file optional.

## operator!=() [8/8]

template<typename _T1, typename _T2>

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

related

Uses `operator==` to find the result.

Definition at line 842 of file stl_pair.h.

## operator<() [1/8]

template<typename _T1, typename _T2>

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 834 of file stl_pair.h.

## operator<() [2/8]

template<typename _Tp, typename _Up>

auto std::operator< | ( | const _Up & | __lhs,
|  | const optional< _Tp > & | __rhs )->__optional_lt_t< _Up, _Tp >

constexpr

Definition at line 1393 of file optional.

## operator<() [3/8]

template<typename _Tp>

bool std::operator< | ( | const optional< _Tp > & | ,
|  | nullopt_t | )

constexpr noexcept

Definition at line 1321 of file optional.

## operator<() [4/8]

template<typename _Tp, typename _Up>

auto std::operator< | ( | const optional< _Tp > & | __lhs,
|  | const _Up & | __rhs )->__optional_lt_t< _Tp, _Up >

constexpr

Definition at line 1387 of file optional.

## operator<() [5/8]

template<typename _Tp, typename _Up>

auto std::operator< | ( | const optional< _Tp > & | __lhs,
|  | const optional< _Up > & | __rhs )->__optional_lt_t< _Tp, _Up >

constexpr

Definition at line 1253 of file optional.

## operator<() [6/8]

template<typename... _TElements, typename... _UElements>

bool std::operator< | ( | const tuple< _TElements... > & | __t,
|  | const tuple< _UElements... > & | __u )

constexpr

Definition at line 1959 of file tuple.

## operator<() [7/8]

template<typename _Tp>

bool std::operator< | ( | nullopt_t | ,
|  | const optional< _Tp > & | __rhs )

constexpr noexcept

Definition at line 1326 of file optional.

## operator<() [8/8]

template<typename _T1, typename _T2>

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 834 of file stl_pair.h.

## operator<=() [1/8]

template<typename _T1, typename _T2>

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

related

Uses `operator<` to find the result.

Definition at line 853 of file stl_pair.h.

## operator<=() [2/8]

template<typename _Tp, typename _Up>

auto std::operator<= | ( | const _Up & | __lhs,
|  | const optional< _Tp > & | __rhs )->__optional_le_t< _Up, _Tp >

constexpr

Definition at line 1417 of file optional.

## operator<=() [3/8]

template<typename _Tp, typename _Up>

auto std::operator<= | ( | const optional< _Tp > & | __lhs,
|  | const _Up & | __rhs )->__optional_le_t< _Tp, _Up >

constexpr

Definition at line 1411 of file optional.

## operator<=() [4/8]

template<typename _Tp, typename _Up>

auto std::operator<= | ( | const optional< _Tp > & | __lhs,
|  | const optional< _Up > & | __rhs )->__optional_le_t< _Tp, _Up >

constexpr

Definition at line 1269 of file optional.

## operator<=() [5/8]

template<typename _Tp>

bool std::operator<= | ( | const optional< _Tp > & | __lhs,
|  | nullopt_t | )

constexpr noexcept

Definition at line 1341 of file optional.

## operator<=() [6/8]

template<typename... _TElements, typename... _UElements>

bool std::operator<= | ( | const tuple< _TElements... > & | __t,
|  | const tuple< _UElements... > & | __u )

constexpr

Definition at line 1984 of file tuple.

## operator<=() [7/8]

template<typename _Tp>

bool std::operator<= | ( | nullopt_t | ,
|  | const optional< _Tp > & | )

constexpr noexcept

Definition at line 1346 of file optional.

## operator<=() [8/8]

template<typename _T1, typename _T2>

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

related

Uses `operator<` to find the result.

Definition at line 853 of file stl_pair.h.

## operator==() [1/8]

template<typename _T1, typename _T2>

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 812 of file stl_pair.h.

## operator==() [2/8]

template<typename _Tp, typename _Up>

auto std::operator== | ( | const _Up & | __lhs,
|  | const optional< _Tp > & | __rhs )->__optional_eq_t< _Up, _Tp >

constexpr

Definition at line 1370 of file optional.

## operator==() [3/8]

template<typename _Tp, typename _Up>

auto std::operator== | ( | const optional< _Tp > & | __lhs,
|  | const _Up & | __rhs )->__optional_eq_t< _Tp, _Up >

constexpr

Definition at line 1364 of file optional.

## operator==() [4/8]

template<typename _Tp, typename _Up>

auto std::operator== | ( | const optional< _Tp > & | __lhs,
|  | const optional< _Up > & | __rhs )->__optional_eq_t< _Tp, _Up >

constexpr

Definition at line 1236 of file optional.

## operator==() [5/8]

template<typename _Tp>

bool std::operator== | ( | const optional< _Tp > & | __lhs,
|  | nullopt_t | )

constexpr noexcept

Definition at line 1296 of file optional.

## operator==() [6/8]

template<typename... _TElements, typename... _UElements>

bool std::operator== | ( | const tuple< _TElements... > & | __t,
|  | const tuple< _UElements... > & | __u )

constexpr

Definition at line 1918 of file tuple.

## operator==() [7/8]

template<typename _Tp>

bool std::operator== | ( | nullopt_t | ,
|  | const optional< _Tp > & | __rhs )

constexpr noexcept

Definition at line 1307 of file optional.

## operator==() [8/8]

template<typename _T1, typename _T2>

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 812 of file stl_pair.h.

## operator>() [1/8]

template<typename _T1, typename _T2>

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

related

Uses `operator<` to find the result.

Definition at line 848 of file stl_pair.h.

## operator>() [2/8]

template<typename _Tp, typename _Up>

auto std::operator> | ( | const _Up & | __lhs,
|  | const optional< _Tp > & | __rhs )->__optional_gt_t< _Up, _Tp >

constexpr

Definition at line 1406 of file optional.

## operator>() [3/8]

template<typename _Tp, typename _Up>

auto std::operator> | ( | const optional< _Tp > & | __lhs,
|  | const _Up & | __rhs )->__optional_gt_t< _Tp, _Up >

constexpr

Definition at line 1400 of file optional.

## operator>() [4/8]

template<typename _Tp, typename _Up>

auto std::operator> | ( | const optional< _Tp > & | __lhs,
|  | const optional< _Up > & | __rhs )->__optional_gt_t< _Tp, _Up >

constexpr

Definition at line 1262 of file optional.

## operator>() [5/8]

template<typename _Tp>

bool std::operator> | ( | const optional< _Tp > & | __lhs,
|  | nullopt_t | )

constexpr noexcept

Definition at line 1332 of file optional.

## operator>() [6/8]

template<typename... _TElements, typename... _UElements>

bool std::operator> | ( | const tuple< _TElements... > & | __t,
|  | const tuple< _UElements... > & | __u )

constexpr

Definition at line 1979 of file tuple.

## operator>() [7/8]

template<typename _Tp>

bool std::operator> | ( | nullopt_t | ,
|  | const optional< _Tp > & | )

constexpr noexcept

Definition at line 1337 of file optional.

## operator>() [8/8]

template<typename _T1, typename _T2>

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

related

Uses `operator<` to find the result.

Definition at line 848 of file stl_pair.h.

## operator>=() [1/8]

template<typename _T1, typename _T2>

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

related

Uses `operator<` to find the result.

Definition at line 860 of file stl_pair.h.

## operator>=() [2/8]

template<typename _Tp, typename _Up>

auto std::operator>= | ( | const _Up & | __lhs,
|  | const optional< _Tp > & | __rhs )->__optional_ge_t< _Up, _Tp >

constexpr

Definition at line 1430 of file optional.

## operator>=() [3/8]

template<typename _Tp>

bool std::operator>= | ( | const optional< _Tp > & | ,
|  | nullopt_t | )

constexpr noexcept

Definition at line 1352 of file optional.

## operator>=() [4/8]

template<typename _Tp, typename _Up>

auto std::operator>= | ( | const optional< _Tp > & | __lhs,
|  | const _Up & | __rhs )->__optional_ge_t< _Tp, _Up >

constexpr

Definition at line 1424 of file optional.

## operator>=() [5/8]

template<typename _Tp, typename _Up>

auto std::operator>= | ( | const optional< _Tp > & | __lhs,
|  | const optional< _Up > & | __rhs )->__optional_ge_t< _Tp, _Up >

constexpr

Definition at line 1278 of file optional.

## operator>=() [6/8]

template<typename... _TElements, typename... _UElements>

bool std::operator>= | ( | const tuple< _TElements... > & | __t,
|  | const tuple< _UElements... > & | __u )

constexpr

Definition at line 1991 of file tuple.

## operator>=() [7/8]

template<typename _Tp>

bool std::operator>= | ( | nullopt_t | ,
|  | const optional< _Tp > & | __rhs )

constexpr noexcept

Definition at line 1357 of file optional.

## operator>=() [8/8]

template<typename _T1, typename _T2>

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

related

Uses `operator<` to find the result.

Definition at line 860 of file stl_pair.h.

## swap() [1/7]

template<typename _T1, typename _T2>

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 879 of file stl_pair.h.

## swap() [2/7]

template<typename _T1, typename _T2>

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 879 of file stl_pair.h.

## swap() [3/7]

template<typename _Tp>

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 189 of file move.h.

## swap() [4/7]

template<typename _Tp, size_t _Nm>

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 213 of file move.h.

References swap().

## swap() [5/7]

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

inline noexcept

Exchange the states of two `any` objects.

Definition at line 429 of file any.

Referenced by __gnu_debug::_Safe_iterator< _Base_iterator, map >::_Safe_iterator(), __gnu_debug::_Safe_local_iterator< _OtherIterator, _Sequence >::_Safe_local_iterator(), __gnu_parallel::_LoserTree< __stable, _Tp, _Compare >::__delete_min_insert(), __gnu_parallel::_LoserTree< false, _Tp, _Compare >::__delete_min_insert(), __rotate(), std::basic_regex< char >::imbue(), std::regex_traits< _CharT >::imbue(), iter_swap(), std::basic_regex< char >::swap(), std::forward_list< _Tp, polymorphic_allocator< _Tp > >::swap(), std::function< _Res(_ArgTypes...)>::swap(), std::match_results< _BidirectionalIterator, polymorphic_allocator< sub_match< _BidirectionalIterator > > >< const char * >::swap(), std::move_only_function< _Res(_ArgTypes...) _GLIBCXX_MOF_CV noexcept(_Noex)>::swap(), std::pair< const __iter_key_t< _InputIterator >, __iter_val_t< _InputIterator > >::swap(), std::sub_match< const char * >::swap(), swap(), swap(), std::tr2::dynamic_bitset< _WordT, _Alloc >::swap(), and std::valarray< _Tp >::swap().

## swap() [6/7]

template<typename _Tp>

enable_if_t< is_move_constructible_v< _Tp > &&is_swappable_v< _Tp > > std::swap | ( | optional< _Tp > & | __lhs,
|  | optional< _Tp > & | __rhs )

inline constexpr delete noexcept

Definition at line 1450 of file optional.

## swap() [7/7]

template<typename... _Elements>

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

inline constexpr delete noexcept

Exchange the values of two tuples.

Exchange the values of two const tuples (if const elements can be swapped).

Definition at line 2182 of file tuple.

## tie()

template<typename... _Elements>

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

constexpr noexcept

Return a tuple of lvalue references bound to the arguments.

Definition at line 2168 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>

auto std::tuple_cat | ( | _Tpls &&... | __tpls | ) | ->typename__tuple_cat_result< _Tpls... >::__type

constexpr

Create a tuple containing all elements from multiple tuple-like objects.

Definition at line 2154 of file tuple.

References forward().

## Variable Documentation

## __is_optional_v

template<typename _Tp>

bool std::__is_optional_v

inline constexpr

Definition at line 681 of file optional.

## __is_optional_v< optional< _Tp > >

template<typename _Tp>

bool std::__is_optional_v< optional< _Tp > >

inline constexpr

Definition at line 683 of file optional.

## __unpack_std_tuple

template<template< typename... > class _Trait, typename _Tp, typename _Tuple>

bool std::__unpack_std_tuple

inline constexpr

Definition at line 2277 of file tuple.

## __unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > & >

template<template< typename... > class _Trait, typename _Tp, typename... _Up>

bool std::__unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > & >

inline constexpr

Definition at line 2292 of file tuple.

## __unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > >

template<template< typename... > class _Trait, typename _Tp, typename... _Up>

bool std::__unpack_std_tuple< _Trait, _Tp, const tuple< _Up... > >

inline constexpr

Definition at line 2288 of file tuple.

## __unpack_std_tuple< _Trait, _Tp, tuple< _Up... > & >

template<template< typename... > class _Trait, typename _Tp, typename... _Up>

bool std::__unpack_std_tuple< _Trait, _Tp, tuple< _Up... > & >

inline constexpr

Definition at line 2284 of file tuple.

## __unpack_std_tuple< _Trait, _Tp, tuple< _Up... > >

template<template< typename... > class _Trait, typename _Tp, typename... _Up>

bool std::__unpack_std_tuple< _Trait, _Tp, tuple< _Up... > >

inline constexpr

Definition at line 2280 of file tuple.

## ignore

_Swallow_assign std::ignore

inline constexpr

Used with std::tie to ignore an element of a tuple

When using std::tie to assign the elements of a tuple to variables, unwanted elements can be ignored by using std::ignore. For example:

int x, y;
std::tie(x, std::ignore, y) = std::make_tuple(1, 2, 3);
std::make_tuple
constexpr tuple< typename __decay_and_strip< _Elements >::__type... > make_tuple(_Elements &&... __args)
Create a tuple containing copies of the arguments.
Definition tuple:2000
std::ignore
constexpr _Swallow_assign ignore
Definition tuple:2232
std::tie
constexpr tuple< _Elements &... > tie(_Elements &... __args) noexcept
Return a tuple of lvalue references bound to the arguments.
Definition tuple:2168

This assignment will perform x=1; std::ignore=2; y=3; which results in the second element being ignored.

Since
  C++11

Definition at line 2232 of file tuple.

## nullopt

nullopt_t std::nullopt

inline constexpr

Tag to disengage optional objects.

Definition at line 89 of file optional.

## piecewise_construct

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, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::insert_or_assign(), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::operator[](), std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace(), and std::map< _Key, _Tp, _Cmp, polymorphic_allocator< pair< const _Key, _Tp > > >::try_emplace().

## tuple_size_v< const tuple< _Types... > >

template<typename... _Types>

size_t std::tuple_size_v< const tuple< _Types... > >

inline constexpr

Definition at line 1771 of file tuple.

## tuple_size_v< tuple< _Types... > >

template<typename... _Types>

size_t std::tuple_size_v< tuple< _Types... > >

inline constexpr

Definition at line 1767 of file tuple.