[allocator.uses.construction]

The following utility functions support three conventions for passing alloc to a constructor:

(2.1)
If T does not use an allocator compatible with alloc, then alloc is ignored.
(2.2)
Otherwise, if T has a constructor invocable as T(allocator_arg_t{}, alloc, args..) (leading-allocator convention), then uses-allocator construction chooses this constructor form.
(2.3)
Otherwise, if T has a constructor invocable as T(args.., alloc) (trailing-allocator convention), then uses-allocator construction chooses this constructor form.

The uses_allocator_construction_args function template takes an allocator and argument list and produces (as a tuple) a new argument list matching one of the above conventions.

Additionally, overloads are provided that treat specializations of pair such that uses-allocator construction is applied individually to the first and second data members.

The make_obj_using_allocator and uninitialized_construct_using_allocator function templates apply the modified constructor arguments to construct an object of type T as a return value or in-place, respectively.

[Note 1:

For uses_allocator_construction_args and make_obj_using_allocator, type T is not deduced and must therefore be specified explicitly by the caller.

— end note]

🔗

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

Returns: A tuple value determined as follows:

(5.1)
If uses_allocator_v<remove_cv_t<T>, Alloc> is false and is_constructible_v<T, Args..> is true, return forward_as_tuple(std::forward<Args>(args).).
(5.2)
Otherwise, if uses_allocator_v<remove_cv_t<T>, Alloc> is true and is_constructible_v<T, allocator_arg_t, const Alloc&, Args..> is true, return tuple<allocator_arg_t, const Alloc&, Args&&.>( allocator_arg, alloc, std::forward<Args>(args).)
(5.3)
Otherwise, if uses_allocator_v<remove_cv_t<T>, Alloc> is true and is_constructible_v<T, Args.., const Alloc&> is true, return forward_as_tuple(std::forward<Args>(args)., alloc).
(5.4)
Otherwise, the program is ill-formed.

[Note 2:

This definition prevents a silent failure to pass the allocator to a constructor of a type for which uses_allocator_v<T, Alloc> is true.

— end note]

🔗

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

Effects: Equivalent to: return make_tuple( piecewise_construct, apply([&alloc](auto&. args1) { return uses_allocator_construction_args<T1>( alloc, std::forward<decltype(args1)>(args1).); }, std::forward<Tuple1>(x)), apply([&alloc](auto&. args2) { return uses_allocator_construction_args<T2>( alloc, std::forward<decltype(args2)>(args2).); }, std::forward<Tuple2>(y));

🔗

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

Effects: Equivalent to: return uses_allocator_construction_args<T>(alloc, piecewise_construct, tuple<>{}, tuple<>{});

🔗

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

Effects: Equivalent to: return uses_allocator_construction_args<T>(alloc, piecewise_construct, forward_as_tuple(std::forward(u)), forward_as_tuple(std::forward<V>(v));

🔗

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

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

🔗

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

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

🔗

template<class T, class Alloc, pair-like P>
  constexpr auto uses_allocator_construction_args(const Alloc& alloc, P&& p) noexcept;

Constraints: remove_cv_t<T> is a specialization of pair and remove_cvref_t is not a specialization of ranges::subrange.

Effects: Equivalent to: return uses_allocator_construction_args<T>(alloc, piecewise_construct, forward_as_tuple(get<0>(std::forward(p)), forward_as_tuple(get<1>(std::forward(p));

🔗

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

Let FUN be the function template: template<class A, class B> void FUN(const pair<A, B>&);

Constraints: remove_cv_t<T> is a specialization of pair, and either:

(20.1)
remove_cvref_t is a specialization of ranges::subrange, or
(20.2)
U does not satisfy pair-like and the expression FUN(u) is not well-formed when considered as an unevaluated operand.

Let pair-constructor be an exposition-only class defined as follows: class pair-constructor { using pair-type = remove_cv_t<T>; / exposition only constexpr auto do-construct(const pair-type& p) const { / exposition only return make_obj_using_allocator<pair-type>(alloc_, p); } constexpr auto do-construct(pair-type&& p) const { / exposition only return make_obj_using_allocator<pair-type>(alloc_, std::move(p)); } const Alloc& alloc_; / exposition only U& u_; / exposition only public: constexpr operator pair-type() const { return do-construct(std::forward(u_)); } };

Returns: make_tuple(pc), where pc is a pair-constructor object whose alloc_ member is initialized with alloc and whose u_ member is initialized with u.

🔗

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

Effects: Equivalent to: return make_from_tuple<T>(uses_allocator_construction_args<T>( alloc, std::forward<Args>(args).);

🔗

template<class T, class Alloc, class. Args>
  constexpr T* uninitialized_construct_using_allocator(T* p, const Alloc& alloc, Args&&. args);

Effects: Equivalent to: return apply([&]<class. U>(U&&. xs) { return construct_at(p, std::forward(xs).); }, uses_allocator_construction_args<T>(alloc, std::forward<Args>(args).);