std::uses_allocator_construction_args (3) - Linux Man Pages

std::uses_allocator_construction_args: std::uses_allocator_construction_args

NAME

std::uses_allocator_construction_args - std::uses_allocator_construction_args

Synopsis


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


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 checks if the specified type supports uses-allocator construction
                                        (class template)
(C++11)


make_obj_using_allocator creates an object of the given type by means of uses-allocator construction
                                        (function template)
(C++20)


uninitialized_construct_using_allocator creates an object of the given type at specified memory location by means of uses-allocator construction
                                        (function template)
(C++20)