std::uses_allocator_construction_args

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( const Alloc& alloc, Args&&... 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( const Alloc& alloc, std::piecewise_construct_t, Tuple1&& x, Tuple2&& y);	(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( const Alloc& alloc, U&& u, V&& v);	(4)	(since C++20)
template< class T, class Alloc, class U, class V > std::tuple</see below/> uses_allocator_construction_args( const Alloc& alloc, const std::pair<U,V>& pr);	(5)	(since C++20)
template< class T, class Alloc, class U, class V > std::tuple</see below/> uses_allocator_construction_args( const Alloc& alloc, std::pair<U,V>&& pr);	(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

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)

Language
Standard Library Headers
Freestanding and hosted implementations
Named requirements
Language support library
Concepts library (C++20)
Diagnostics library
Utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Input/output library
Localizations library
Regular expressions library (C++11)
Atomic operations library (C++11)
Thread support library (C++11)
Filesystem library (C++17)
Technical Specifications

uses_allocator (C++11)	checks if the specified type supports uses-allocator construction (class template)
make_obj_using_allocator (C++20)	creates an object of the given type by means of uses-allocator construction (function template)
uninitialized_construct_using_allocator (C++20)	creates an object of the given type at specified memory location by means of uses-allocator construction (function template)

std::uses_allocator_construction_args

Parameters

Return value

Example

Notes

See also