std::uses_allocator_construction_args - cppreference.com

De cppreference.com

Definido en el archivo de encabezado `<memory>`

`T` no es una especialización de std::pair
`template< class T, class Alloc, class... Args > constexpr auto uses_allocator_construction_args( const Alloc& alloc, Args&&... args) noexcept;`	(1)	(desde C++20)

`T` es una especialización de std::pair
`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;`	(2)	(desde C++20)
`template< class T, class Alloc > constexpr auto uses_allocator_construction_args( const Alloc& alloc ) noexcept;`	(3)	(desde C++20)
`template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, U&& u, V&& v) noexcept;`	(4)	(desde C++20)
`template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, std::pair<U, V>& pr ) noexcept;`	(5)	(desde C++23)
`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;`	(6)	(desde C++20)
`template< class T, class Alloc, class U, class V > constexpr auto uses_allocator_construction_args( const Alloc& alloc, std::pair<U, V>&& pr ) noexcept;`	(7)	(desde C++20)
`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;`	(8)	(desde C++23)

Prepara la lista de argumentos necesaria para crear un objeto del tipo dado T mediante la construcción con uso de asignador.

1) Esta sobrecarga solo participa en la resolución de sobrecargas si T no es una especialización de std::pair. Devuelve std::tuple determinado de la siguiente manera:

Si std::uses_allocator_v<T, Alloc> es false y std::is_constructible_v<T, Args...> es true, devuelve std::forward_as_tuple(std::forward<Args>(args)...).
De lo contrario, si std::uses_allocator_v<T, Alloc> es true y std::is_constructible_v<T, std::allocator_arg_t, const Alloc&, Args...> es true, devuelve std::tuple<std::allocator_arg_t, const Alloc&, Args&&...>(std::allocator_arg, alloc, std::forward<Args>(args)...).
De lo contrario, si std::uses_allocator_v<T, Alloc> es true y std::is_constructible_v<T, Args..., const Alloc&> es true, devuelve std::forward_as_tuple(std::forward<Args>(args)..., alloc).
De lo contrario, el programa está mal formado.

2) Esta sobrecarga solo participa en la resolución de sobrecargas si T es una especialización de std::pair. Para T que es std::pair<T1, T2>, equivalente a

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) Esta sobrecarga solo participa en la resolución de sobrecargas si T es una especialización de std::pair. Equivalente a

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

4) Esta sobrecarga solo participa en la resolución de sobrecargas si T es una especialización de std::pair. Equivalente a

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) Esta sobrecarga solo participa en la resolución de sobrecargas si T es una especialización de std::pair. Equivalente a

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) Esta sobrecarga solo participa en la resolución de sobrecargas si T es una especialización de std::pair. Equivalente a

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))));

Parámetros

alloc	-	El asignador de memoria a usar.
args	-	Los argumentos a pasar al constructor de `T`.
x	-	Tupla de argumentos a pasar a los constructores de `T`.first.
y	-	Tupla de argumentos a pasar a los constructores de `T`.second.
u	-	Argumento único a pasar al constructor de `T`.first
v	-	Argumento único a pasar al constructor de `T`.second
pr	-	Un par cuyo miembro `.first` se pasará al constructor de `T`.first y `.second` se pasará al constructor de `T`.second.

Valor de retorno

std::tuple de argumentos adecuados a pasar al constructor de T.

Ejemplo

Notas

Las sobrecargas (2-8) proporcionan la propagación del asignador en std::pair, que no admite convenciones de llamadas de asignador anterior ni de asignador posterior (a diferencia de, por ejemplo, std::tuple, que usa la convención de asignador anterior).

Véase también

Categorías: