std:: uses_allocator_construction_args

From cppreference.net

Definido en el 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)
template < class T, class Alloc, class NonPair > constexpr auto uses_allocator_construction_args ( const Alloc & alloc, NonPair && non_pair ) noexcept ;	(9)	(desde C++20)

Prepara la lista de argumentos necesaria para crear un objeto del tipo dado T mediante la construcción uses-allocator .

1) Esta sobrecarga participa en la resolución de sobrecarga solo si

no es una especialización de std::pair . Retorna 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 , retorna 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 , retorna
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 , retorna std:: forward_as_tuple ( std:: forward < Args > ( args ) ..., alloc ) .
De lo contrario, el programa está mal formado.

2) Esta sobrecarga participa en la resolución de sobrecarga solo si

es una especialización de std::pair . Para

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 participa en la resolución de sobrecarga solo si

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 participa en la resolución de sobrecarga solo si

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 participa en la resolución de sobrecarga solo si

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 participa en la resolución de sobrecarga solo si

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

9) Esta sobrecarga participa en la resolución de sobrecarga solo si

es una especialización de std::pair , y dada la plantilla de función solo de exposición

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

, /*deduce-as-pair*/ ( non_pair ) está mal formada cuando se considera como un operando no evaluado.
Sea la clase solo de exposición pair-constructor definida como

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

Esta sobrecarga es equivalente a return std:: make_tuple ( pair_construction ) ; , donde


        pair_construction

es un valor de tipo


        
         pair-constructor

cuyos miembros


        
         alloc_

u_

son


        alloc


        non_pair

respectivamente.

Contenidos

Parámetros

alloc	-	el asignador a utilizar
args	-	los argumentos a pasar al constructor de `T`
x	-	tupla de argumentos a pasar a los constructores del `first` miembro de datos de `T`
y	-	tupla de argumentos a pasar a los constructores del `second` miembro de datos de `T`
u	-	argumento único a pasar al constructor del `first` miembro de datos de `T`
v	-	argumento único a pasar al constructor del `second` miembro de datos de `T`
pr	-	un par cuyo miembro de datos `first` se pasará al constructor del `first` miembro de datos de `T` y cuyo miembro de datos `second` se pasará al constructor del `second` miembro de datos de `T`
non_pair	-	argumento único a convertir a un std::pair para construcción posterior

Valor de retorno

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

Notas

Las sobrecargas (2-9) proporcionan propagación del asignador hacia std::pair , que no admite ni convenciones de llamada con asignador inicial ni con asignador final (a diferencia de, por ejemplo, std::tuple , que utiliza la convención de asignador inicial).

Cuando se utiliza en la construcción uses-allocator, la función de conversión de pair-constructor convierte primero el argumento proporcionado a std::pair , y luego construye el resultado a partir de ese std::pair mediante construcción uses-allocator.

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR	Aplicado a	Comportamiento publicado	Comportamiento correcto
LWG 3525	C++20	ninguna sobrecarga podía manejar tipos no- `pair` convertibles a `pair`	sobrecarga reconstructora añadida

Véase también

uses_allocator (C++11)	verifica si el tipo especificado admite la construcción uses-allocator (plantilla de clase)
make_obj_using_allocator (C++20)	crea un objeto del tipo dado mediante construcción uses-allocator (plantilla de función)
uninitialized_construct_using_allocator (C++20)	crea un objeto del tipo dado en una ubicación de memoria específica mediante construcción uses-allocator (plantilla de función)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

std:: uses_allocator_construction_args

Contenidos

Parámetros

Valor de retorno

Notas

Ejemplo

Informes de defectos

Véase también