[allocator.uses] (original) (raw)

20.2.8.1 uses_allocator trait [allocator.uses.trait]

template<class T, class Alloc> struct uses_allocator;

Remarks: Automatically detects whether T has a nested allocator_type that is convertible from Alloc.

The implementation shall provide a definition that is derived from true_type if the qualified-id T::allocator_typeis valid and denotes a type ([temp.deduct]) andis_convertible_v<Alloc, T::allocator_type> != false, otherwise it shall be derived from false_type.

A program may specialize this template to derive fromtrue_type for a program-defined type T that does not have a nestedallocator_type but nonetheless can be constructed with an allocator where either:

the first argument of a constructor has type allocator_arg_t and the second argument has type Alloc or
the last argument of a constructor has type Alloc.

20.2.8.2 Uses-allocator construction [allocator.uses.construction]

Uses-allocator constructionwith allocator alloc and constructor arguments args...refers to the construction of an object of type Tsuch that alloc is passed to the constructor of Tif T uses an allocator type compatible with alloc.

When applied to the construction of an object of type T, it is equivalent to initializing it with the value of the expressionmake_obj_using_allocator<T>(alloc, args...), described below.

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

If T does not use an allocator compatible with alloc, then alloc is ignored.
Otherwise, if T has a constructor invocable asT(allocator_arg, alloc, args...) (leading-allocator convention), then uses-allocator construction chooses this constructor form.
Otherwise, if T has a constructor invocable asT(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 pairsuch that uses-allocator construction is applied individually to the first and second data members.

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

[Note 1:

For uses_allocator_construction_args andmake_obj_using_allocator, type Tis 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;

Constraints: remove_cv_t<T> is not a specialization of pair.

Returns: A tuple value determined as follows:

If uses_allocator_v<remove_cv_t<T>, Alloc> is false andis_constructible_v<T, Args...> is true, return forward_as_tuple(std::forward<Args>(args)...).
Otherwise, if uses_allocator_v<remove_cv_t<T>, Alloc> is true andis_constructible_v<T, allocator_arg_t, const Alloc&, Args...> is true, returntuple<allocator_arg_t, const Alloc&, Args&&...>( allocator_arg, alloc, std::forward<Args>(args)...)
Otherwise, if uses_allocator_v<remove_cv_t<T>, Alloc> is true andis_constructible_v<T, Args..., const Alloc&> is true, return forward_as_tuple(std::forward<Args>(args)..., alloc).
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 whichuses_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;

Let T1 be T::first_type.

Let T2 be T::second_type.