libstdc++
Utilities
Collaboration diagram for Utilities:

Modules

 Function Objects
 
 Memory
 
 Metaprogramming
 
 Rational Arithmetic
 
 Time
 

Classes

struct  std::_Tuple_impl< _Idx, _Elements >
 
struct  std::_Tuple_impl< _Idx, _Head, _Tail...>
 
class  std::bitset< _Nb >
 
struct  std::pair< _T1, _T2 >
 
struct  std::piecewise_construct_t
 
class  std::tuple< _Elements >
 
class  std::tuple< _T1, _T2 >
 
struct  std::tuple_element< 0, tuple< _Head, _Tail...> >
 
struct  std::tuple_element< __i, tuple< _Head, _Tail...> >
 
struct  std::tuple_element< __i, tuple<> >
 
struct  std::tuple_size< tuple< _Elements...> >
 
struct  std::type_index
 
struct  std::uses_allocator< tuple< _Types...>, _Alloc >
 

Macros

#define __cpp_lib_tuples_by_type
 

Typedefs

template<typename _Res , typename _Callable , typename... _Args>
using std::__can_invoke_as_nonvoid = __enable_if_t< __and_< __not_< is_void< _Res >>, is_convertible< typename __invoke_result< _Callable, _Args...>::type, _Res > >::value, _Res >
 
template<typename _Res , typename _Callable , typename... _Args>
using std::__can_invoke_as_void = __enable_if_t< __and_< is_void< _Res >, __is_invocable< _Callable, _Args...>>::value, _Res >
 
typedef __tuple_concater
< __ret, __idx, _Tpls...> 
std::__concater
 
template<typename _Tp >
using std::__empty_not_final = typename conditional< __is_final(_Tp), false_type, __is_empty_non_tuple< _Tp >>::type
 
typedef __make_1st_indices
< _Tpls...>::__type 
std::__idx
 
typedef __combine_tuples
< typename __make_tuple< _Tpls >
::__type...>::__type 
std::__tuple_cat_result< _Tpls >::__type
 

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 _Tp , typename _Up = _Tp>
constexpr _Tp std::__exchange (_Tp &__obj, _Up &&__new_val)
 
template<std::size_t __i, typename _Head , typename... _Tail>
constexpr _Head & std::__get_helper (_Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<std::size_t __i, typename _Head , typename... _Tail>
constexpr const _Head & std::__get_helper (const _Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<typename _Head , size_t __i, typename... _Tail>
constexpr _Head & std::__get_helper2 (_Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<typename _Head , size_t __i, typename... _Tail>
constexpr const _Head & std::__get_helper2 (const _Tuple_impl< __i, _Head, _Tail...> &__t) noexcept
 
template<typename _Tp , typename _Up = typename __inv_unwrap<_Tp>::type>
constexpr _Up && std::__invfwd (typename remove_reference< _Tp >::type &__t) noexcept
 
template<typename _Res , typename _Fn , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_other, _Fn &&__f, _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 _MemFun , typename _Tp , typename... _Args>
constexpr _Res std::__invoke_impl (__invoke_memfun_deref, _MemFun &&__f, _Tp &&__t, _Args &&...__args)
 
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res std::__invoke_impl (__invoke_memobj_ref, _MemPtr &&__f, _Tp &&__t)
 
template<typename _Res , typename _MemPtr , typename _Tp >
constexpr _Res std::__invoke_impl (__invoke_memobj_deref, _MemPtr &&__f, _Tp &&__t)
 
template<typename _Res , typename _Callable , typename... _Args>
constexpr
__can_invoke_as_nonvoid< _Res,
_Callable, _Args...> 
std::__invoke_r (_Callable &&__fn, _Args &&...__args)
 
template<typename _Tp >
constexpr _Tp * std::addressof (_Tp &__r) noexcept
 
template<typename _Tp >
const _Tp * std::addressof (const _Tp &&)=delete
 
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<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t
< __i, tuple< _Elements...> > & 
std::get (tuple< _Elements...> &__t) noexcept
 
template<std::size_t __i, typename... _Elements>
constexpr const
__tuple_element_t< __i, tuple
< _Elements...> > & 
std::get (const tuple< _Elements...> &__t) noexcept
 
template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t
< __i, tuple< _Elements...> > && 
std::get (tuple< _Elements...> &&__t) noexcept
 
template<std::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 _Tp & std::get (tuple< _Types...> &__t) noexcept
 
template<typename _Tp , typename... _Types>
constexpr _Tp && std::get (tuple< _Types...> &&__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<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 _Callable , typename... _Args>
constexpr __invoke_result
< _Callable, _Args...>::type 
std::noexcept (__is_nothrow_invocable< _Callable, _Args...>::value)
 
template<typename _Tp >
constexpr enable_if< __and_
< __not_< __is_tuple_like< _Tp >
>, is_move_constructible< _Tp >
, is_move_assignable< _Tp >
>::value >::type 
std::noexcept () is_nothrow_move_assignable< _Tp >>
 
template<typename... _Elements>
constexpr enable_if< __and_
< __is_swappable< _Elements >
...>::value >::type 
std::noexcept (noexcept(__x.swap(__y)))
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator!= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator< (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator<= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator== (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator> (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename... _TElements, typename... _UElements>
constexpr bool std::operator>= (const tuple< _TElements...> &__t, const tuple< _UElements...> &__u)
 
template<typename _Tp , size_t _Nm>
constexpr enable_if
< __is_swappable< _Tp >::value >
::type 
std::swap (_Tp(&__a)[_Nm], _Tp(&__b)[_Nm]) noexcept(/*conditional */)
 
template<typename... _Elements>
constexpr enable_if<!__and_
< __is_swappable< _Elements >
...>::value >::type 
std::swap (tuple< _Elements...> &, tuple< _Elements...> &)=delete
 
template<typename... _Elements>
constexpr tuple< _Elements &...> std::tie (_Elements &...__args) noexcept
 

Variables

constexpr _Swallow_assign std::ignore
 
constexpr piecewise_construct_t std::piecewise_construct
 
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 
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.

Typedef Documentation

template<typename... _Tpls>
constexpr auto std::__tuple_cat_result< _Tpls, typename >::__type

tuple_cat

Definition at line 1544 of file tuple.

Function Documentation

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

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

Parameters
__firstArguments for the first member of the pair.
__secondArguments 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 1674 of file tuple.

template<typename _Tp >
constexpr _Tp* std::addressof ( _Tp &  __r)
inlinenoexcept

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

Parameters
__rReference to an object or function.
Returns
The actual address.

Definition at line 140 of file move.h.

References std::__addressof().

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

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

Forward an lvalue.

Returns
The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 76 of file move.h.

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

Forward an rvalue.

Returns
The parameter cast to the specified type.

This function is used to implement "perfect forwarding".

Definition at line 87 of file move.h.

template<typename... _Elements>
constexpr tuple<_Elements&&...> std::forward_as_tuple ( _Elements &&...  __args)
noexcept

std::forward_as_tuple

Definition at line 1486 of file tuple.

template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...> >& std::get ( tuple< _Elements...> &  __t)
noexcept

Return a reference to the ith element of a tuple.

Definition at line 1294 of file tuple.

template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...> >& std::get ( const tuple< _Elements...> &  __t)
noexcept

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

Definition at line 1300 of file tuple.

template<std::size_t __i, typename... _Elements>
constexpr __tuple_element_t<__i, tuple<_Elements...> >&& std::get ( tuple< _Elements...> &&  __t)
noexcept

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

Definition at line 1306 of file tuple.

template<std::size_t __i, typename... _Elements>
constexpr const __tuple_element_t<__i, tuple<_Elements...> >&& std::get ( const tuple< _Elements...> &&  __t)
noexcept

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

Definition at line 1315 of file tuple.

template<typename _Tp , typename... _Types>
constexpr _Tp& std::get ( tuple< _Types...> &  __t)
noexcept

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

Definition at line 1338 of file tuple.

template<typename _Tp , typename... _Types>
constexpr _Tp&& std::get ( tuple< _Types...> &&  __t)
noexcept

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

Definition at line 1344 of file tuple.

template<typename _Tp , typename... _Types>
constexpr const _Tp& std::get ( const tuple< _Types...> &  __t)
noexcept

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

Definition at line 1350 of file tuple.

template<typename _Tp , typename... _Types>
constexpr const _Tp&& std::get ( const tuple< _Types...> &&  __t)
noexcept

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

Definition at line 1357 of file tuple.

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
__xThe first object.
__yThe 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.

template<typename _Tp >
constexpr std::remove_reference<_Tp>::type&& std::move ( _Tp &&  __t)
noexcept

Convert a value to an rvalue.

Parameters
__tA thing of arbitrary type.
Returns
The parameter cast to an rvalue-reference to allow moving it.

Definition at line 101 of file move.h.

Referenced by std::basic_regex< typename, typename >::assign(), std::shared_ptr< _Tp >::atomic_compare_exchange_strong_explicit(), std::function< _Res(_ArgTypes...)>::function(), std::future< _Res >::get(), std::unordered_set< _Value, _Hash, _Pred, _Alloc >::insert(), std::multimap< _Key, _Tp, _Compare, _Alloc >::insert(), std::unordered_map< _Key, _Tp, _Hash, _Pred >::insert(), std::map< _Key, _Tp, _Compare, _Alloc >::insert(), std::unordered_multiset< _Value, _Hash, _Pred, _Alloc >::insert(), std::vector< block_type, allocator_type >::insert(), std::list< __inp, __rebind_inp >::insert(), std::unordered_multimap< _Key, _Tp, _Hash, _Pred, _Alloc >::insert(), std::deque< _StateSeqT >::insert(), std::forward_list< _Tp, _Alloc >::merge(), std::move_if_noexcept(), std::tr2::dynamic_bitset< _WordT, _Alloc >::operator&=(), std::function< _Res(_ArgTypes...)>::operator=(), std::basic_regex< typename, typename >::operator=(), std::forward_list< _Tp, _Alloc >::operator=(), std::vector< block_type, allocator_type >::operator=(), std::list< __inp, __rebind_inp >::operator=(), std::deque< _StateSeqT >::operator=(), std::unordered_map< _Key, _Tp, _Hash, _Pred >::operator[](), std::unique_ptr< _Result< _Res > >::reset(), std::unique_ptr< _Tp[], _Dp >::reset(), std::list< __inp, __rebind_inp >::splice(), and std::unique_ptr< _Result< _Res > >::~unique_ptr().

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

Conditionally convert a value to an rvalue.

Parameters
__xA 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 121 of file move.h.

References std::move().

template<typename _Callable , typename... _Args>
constexpr __invoke_result<_Callable, _Args...>::type std::noexcept ( __is_nothrow_invocable< _Callable, _Args...>::value  )

Invoke a callable object.

Definition at line 90 of file invoke.h.

template<typename _Tp >
constexpr enable_if<__and_<__not_<__is_tuple_like<_Tp> >, is_move_constructible<_Tp>, is_move_assignable<_Tp> >::value>::type std::noexcept ( )
inline

Swaps two values.

Parameters
__aA thing of arbitrary type.
__bAnother thing of arbitrary type.
Returns
Nothing.

Definition at line 191 of file move.h.

template<typename _T1 , typename _T2 >
constexpr enable_if< __and_< __is_swappable< _T1 >, __is_swappable< _T2 > >::value >::type noexcept ( noexcept(__x.swap(__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 534 of file stl_pair.h.

template<typename... _Elements>
constexpr enable_if<__and_<__is_swappable<_Elements>...>::value >::type std::noexcept ( noexcept(__x.swap(__y))  )
related

swap

Definition at line 1630 of file tuple.

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.

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

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

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

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.

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.

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.

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

Swap the contents of two arrays.

Definition at line 213 of file move.h.

template<typename... _Elements>
constexpr tuple<_Elements&...> std::tie ( _Elements &...  __args)
noexcept

tie

Definition at line 1615 of file tuple.

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

Variable Documentation

constexpr piecewise_construct_t std::piecewise_construct
inline

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 >::operator[]().