std::uses_allocator_construction_args
From cppreference.com
Defined in header <memory>
|
||
T is not a specialization of std::pair |
||
template< class T, class Alloc, class... Args > std::tuple</*see below*/> uses_allocator_construction_args( |
(1) | (since C++20) |
T is a specialization of std::pair |
||
template< class T, class Alloc, class Tuple1, class Tuple2 > std::tuple</*see below*/> uses_allocator_construction_args( |
(2) | (since C++20) |
template< class T, class Alloc > std::tuple</*see below*/> uses_allocator_construction_args( const Alloc& alloc ); |
(3) | (since C++20) |
template< class T, class Alloc, class U, class V > std::tuple</*see below*/> uses_allocator_construction_args( |
(4) | (since C++20) |
template< class T, class Alloc, class U, class V > std::tuple</*see below*/> uses_allocator_construction_args( |
(5) | (since C++20) |
template< class T, class Alloc, class U, class V > std::tuple</*see below*/> uses_allocator_construction_args( |
(6) | (since C++20) |
Prepares the argument list needed to create an object of the given type T
by means of uses-allocator construction.
1) This overload only participates in overload resolution if T is not a specialization of std::pair. Returns std::tuple determined as follows:
- If std::uses_allocator_v<T, Alloc> is false and std::is_constructible_v<T, Args...> is true, returns std::forward_as_tuple(std::forward<Args>(args)...)
- Otherwise, if std::uses_allocator_v<T, Alloc> is true and std::is_constructible_v<T, std::allocator_arg_t, Alloc, Args...> is true, returns std::tuple<std::allocator_arg_t, const Alloc&, Args&&...>(std::allocator_arg, alloc, std::forward<Args>(args)...)
- Otherwise, if std::uses_allocator_v<T, Alloc> is true and std::is_constructible_v<T, Args..., Alloc> is true, returns std::forward_as_tuple(std::forward<Args>(args)..., alloc)
- Otherwise, the program is ill-formed
2) This overload only participates in overload resolution if T is a specialization of std::pair. For T = std::pair<T1, T2>, equivalent to
return std::make_tuple( std::piecewise_construct, std::apply( [&alloc](auto&&... args1) { return std::uses_allocator_construction_args<T1>( alloc, std::forward<decltype(args1)>(args1)...); }, std::forward<Tuple1>(x)), std::apply( [&alloc](auto&&... args2) { return std::uses_allocator_construction_args<T2>( alloc, std::forward<decltype(args2)>(args2)...); }, std::forward<Tuple2>(y)) );
3) This overload only participates in overload resolution if T is a specialization of std::pair. Equivalent to
return std::uses_allocator_construction_args<T>(alloc, std::piecewise_construct, std::tuple<>{}, std::tuple<>{} );
4) This overload only participates in overload resolution if T is a specialization of std::pair. Equivalent to
return std::uses_allocator_construction_args<T>( alloc, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(u)), std::forward_as_tuple(std::forward<V>(v)) );
5) This overload only participates in overload resolution if T is a specialization of std::pair. Equivalent to
return std::uses_allocator_construction_args<T>( alloc, std::piecewise_construct, std::forward_as_tuple(pr.first), std::forward_as_tuple(pr.second) );
6) This overload only participates in overload resolution if T is a specialization of std::pair. Equivalent to
return std::uses_allocator_construction_args<T>( alloc, std::piecewise_construct, std::forward_as_tuple(std::move(pr).first), std::forward_as_tuple(std::move(pr).second));
Parameters
alloc | - | the allocator to use. |
args | - | the arguments to pass to T's constructor |
x | - | tuple of arguments to pass to the constructors of T's .first |
y | - | tuple of arguments to pass to the constructors of T's .second |
u | - | single argument to pass to the constructor of T's .first |
v | - | single argument to pass to the constructor of T's .second |
pr | - | a pair whose .first will be passed to the constructor of T's .first and .second will be passed to the constructor of T's .second |
Return value
std::tuple of arguments suitable for passing to the constructor of T
Example
This section is incomplete Reason: no example |
Notes
The overloads (2-6) provide allocator propagation into std::pair, which supports neither leading-allocator nor trailing-allocator calling conventions (unlike, e.g. std::tuple, which uses leading-allocator convention)
See also
(C++11) |
checks if the specified type supports uses-allocator construction (class template) |
(C++20) |
creates an object of the given type by means of uses-allocator construction (function template) |
creates an object of the given type at specified memory location by means of uses-allocator construction (function template) |