# std::uses_allocator_construction_args

From cppreference.com
< cpp‎ | memory

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

| 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

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)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/uses_allocator_construction_args&oldid=107908"