std::uses_allocator_construction_args

template< class T, class Alloc, class... Args >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    Args&&... args ) noexcept;

template< class T, class Alloc, class Tuple1, class Tuple2 >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    std::piecewise_construct_t, Tuple1&& x, Tuple2&& y ) noexcept;

template< class T, class Alloc >
constexpr auto uses_allocator_construction_args( const Alloc& alloc ) noexcept;

template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    U&& u, V&& v ) noexcept;

template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    std::pair<U, V>& pr ) noexcept;

template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    const std::pair<U, V>& pr ) noexcept;

template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    std::pair<U, V>&& pr ) noexcept;

template< class T, class Alloc, class U, class V >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    const std::pair<U, V>&& pr ) noexcept;

template< class T, class Alloc, class NonPair >
constexpr auto uses_allocator_construction_args( const Alloc& alloc,
    NonPair&& non_pair ) noexcept;

2) Эта перегрузка участвует в разрешении перегрузки только в том случае, если T является специализацией std::pair. Для T, который является std::pair<T1, T2>, эквивалентна

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) Эта перегрузка участвует в разрешении перегрузки только в том случае, если T является специализацией std::pair. Эквивалентна

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct, std::tuple<>{}, std::tuple<>{}
);

4) Эта перегрузка участвует в разрешении перегрузки только в том случае, если T является специализацией std::pair. Эквивалентна

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,6) Эта перегрузка участвует в разрешении перегрузки только в том случае, если T является специализацией std::pair. Эквивалентна

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct,
    std::forward_as_tuple(pr.first),
    std::forward_as_tuple(pr.second)
);

7,8) Эта перегрузка участвует в разрешении перегрузки только в том случае, если T является специализацией std::pair. Эквивалентна

return std::uses_allocator_construction_args<T>(alloc,
    std::piecewise_construct,
    std::forward_as_tuple(std::get<0>(std::move(pr))),
    std::forward_as_tuple(std::get<1>(std::move(pr)))
);

9) Эта перегрузка участвует в разрешении перегрузки только в том случае, если T является специализацией std::pair и данный шаблон функции, предназначенный только для описания,

template<class A, class B>
void /*deduce-as-pair*/(const std::pair<A, B>&);

, /*deduce-as-pair*/(non_pair) некорректен при использовании в качестве невычисляемого операнда.
Пусть класс pair-constructor, предназначенный только для описания, определён следующим образом:

class /*pair-constructor*/
{
    const Alloc& alloc_; // exposition only
    NonPair&     u_;     // exposition only

    constexpr reconstruct(const std::remove_cv<T>& p) const // exposition only
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, p);
    }

    constexpr reconstruct(std::remove_cv<T>&& p) const // exposition only
    {
        return std::make_obj_using_allocator<std::remove_cv<T>>(alloc_, std::move(p));
    }

public:
    constexpr operator std::remove_cv<T>() const
    {
        return reconstruct(std::forward<NonPair>(u_));
    }
};

Эта перегрузка эквивалентна return std::make_tuple(pair_construction);, где pair_construction — значение типа pair-constructor, члены alloc_ и u_ которого равны соответственно alloc и non_pair.

Параметры

alloc	-	аллокатор, который следует использовать
args	-	аргументы, передаваемые конструктору T
x	-	кортеж аргументов, передаваемых конструкторам элемента данных first типа T
y	-	кортеж аргументов, передаваемых конструкторам элемента данных second типа T
u	-	единственный аргумент, передаваемый конструктору элемента данных first типа T
v	-	единственный аргумент, передаваемый конструктору элемента данных second типа T
pr	-	пара, элемент данных first которой будет передан конструктору элемента данных first типа T, а элемент данных second — конструктору элемента данных second типа T
non_pair	-	единственный аргумент, преобразуемый в std::pair для последующего конструирования

Возвращаемое значение

std::tuple аргументов, подходящих для передачи конструктору T.

Примечания

Перегрузки (2-9) обеспечивают распространение аллокатора в std::pair, который не поддерживает соглашения о вызове с аллокатором в начале или в конце списка аргументов (в отличие, например, от std::tuple, использующего соглашение с аллокатором в начале списка).

При использовании в конструировании с использованием аллокатора функция преобразования pair-constructor сначала преобразует переданный аргумент в std::pair, а затем конструирует результат из этого std::pair посредством конструирования с использованием аллокатора.

Пример

Отчёты об ошибках

Следующие отчёты об ошибках, изменяющие поведение, были применены задним числом к ранее опубликованным стандартам C++.

DR	Применяется к	Поведение в опубликованной редакции	Исправленное поведение
LWG 3525	C++20	ни одна перегрузка не могла обрабатывать типы, не являющиеся pair и преобразуемые в pair	добавлена перегрузка, выполняющая повторное конструирование

См. также

uses_allocator (C++11)	проверяет, поддерживает ли указанный тип конструирование с использованием аллокатора (шаблон класса)
make_obj_using_allocator (C++20)	создаёт объект заданного типа посредством конструирования с использованием аллокатора (шаблон функции)
uninitialized_construct_using_allocator (C++20)	создаёт объект заданного типа в указанной области памяти посредством конструирования с использованием аллокатора (шаблон функции)