std::pmr::polymorphic_allocator<T>::construct
De cppreference.com
< cpp | memory | polymorphic allocator
| template < class U, class... Args > void construct( U* p, Args&&... args ); |
(1) | (desde C++17) |
| template< class T1, class T2, class... Args1, class... Args2 > void construct( std::pair<T1, T2>* p, |
(2) | (desde C++17) (hasta C++20) |
| template< class T1, class T2 > void construct( std::pair<T1, T2>* p ); |
(3) | (desde C++17) (hasta C++20) |
| template< class T1, class T2, class U, class V > void construct( std::pair<T1, T2>* p, U&& x, V&& y ); |
(4) | (desde C++17) (hasta C++20) |
| (5) | (desde C++17) (hasta C++20) |
|
| (6) | (desde C++17) (hasta C++20) |
|
| template< class T1, class T2, class NonPair > void construct( std::pair<T1, T2>* p, NonPair&& non_pair ); |
(7) | (desde C++17) (hasta C++20) |
Construye un objeto en el almacenamiento asignado, pero no inicializado, al que apunta p con los argumentos del constructor provistos. Si el objeto es del tipo que usa asignadores, o si es std::pair, pasa this->resource() al objeto construido.
1) Crea un objeto del tipo dado
U por medio de la construcción con uso de asignador en la ubicación de memoria no inicializada indicada por p, usando *this como asignador. Esta sobrecarga solo participa en la resolución de sobrecargas si U no es una especialización de std::pair. (hasta C++20)|
2) Primero, si
T1 o T2 es consciente de asignador, modifica las tuplas x e y para incluir this- >resource(), dando como resultado las dos nuevas tuplas xprime y yprime, de acuerdo con las siguientes tres reglas:2a) si
T1 no es consciente de asignador (std::uses_allocator<T1, polymorphic_allocator>::value==false) y std::is_constructible<T1, Args1...>::value==true, entonces xprime es x, sin modificar.2b) si
T1 es consciente de asignador (std::uses_allocator<T1, polymorphic_allocator>::value==true), y su constructor toma una etiqueta de asignador (std::is_constructible<T1, std::allocator_arg_t, polymorphic_allocator, Args1...>::value==true), entonces xprime es
std::tuple_cat(std::make_tuple(std::allocator_arg, *this), std::move(x)).2c) si
T1 es consciente de asignador (std::uses_allocator<T1, polymorphic_allocator>::value==true), y su constructor toma el asignador como último argumento (std::is_constructible<T1, Args1..., polymorphic_allocator>::value==true), entonces xprime es std::tuple_cat(std::move(x), std::make_tuple(*this)).2d) De lo contrario, el programa está mal formado..
Las mismas reglas se aplican a
T2 y al reemplazo de y con yprime. Una vez que se construyen
xprime e yprime, construye el par p en el almacenamiento asignado como si fuera por ::new((void *) p) pair<T1, T2>(std::piecewise_construct, std::move(xprime), std::move(yprime));3) Equivalente a construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>()), es decir, pasa el recurso de memoria a los tipos miembro del std::pair si los aceptan.
4) Equivalente a
construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(x)), std::forward_as_tuple(std::forward<V>(y))) 5) Equivalente a
construct(p, std::piecewise_construct, std::forward_as_tuple(xy.first), std::forward_as_tuple(xy.second)) 6) Equivalente a
construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(xy.first)), std::forward_as_tuple(std::forward<V>(xy.second))) 7) Esta sobrecarga solo participa en la resolución de sobrecargas si dada la plantilla de función de solo exposición
template< class A, class B > void /*deducir-como-par*/( const std::pair<A, B>& ); , /*deducir-como-par*/(non_pair) está mal formado cuando se considera como un operando no evaluado. Equivalente a construct<T1, T2, T1, T2>(p, std::forward<NonPair>(non_pair)); |
(hasta C++20) |
Contenido |
[editar] Parámetros
| p | - | Puntero al almacenamiento asignado, pero no inicializado. |
| args... | - | Los argumentos del constructor a pasar al constructor de T.
|
| x | - | Los argumentos del constructor a pasar al constructor de T1.
|
| y | - | Los argumentos del constructor a pasar al constructor de T2.
|
| xy | - | El std::pair cuyos dos miembros son los argumentos del constructor de T1 y T2.
|
| non_pair | - | Argumento no std::pair a convertir a std::pair para construcción adicional. |
[editar] Valor de retorno
(Ninguno)
[editar] Notas
Esta función se llama (a través de std::allocator_traits) por cualquier objeto consciente de asignador, como std::pmr::vector (u otro std::vector que recibió un std::pmr::polymorphic_allocator como el asignador a usar).
[editar] Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 2969 | C++17 | La construcción con uso de asignador pasaba resource().
|
Pasa *this.
|
| LWG 2975 | C++17 | La primera sobrecarga se usaba erróneamente para la construcción de std::pair en algunos casos. | Se restringió para que no aceptara std::pair. |
| LWG 3525 | C++17 | Ninguna sobrecarga podía manejar tipos no std::pair convertibles a std::pair. | Se agregó una sobrecarga de reconstrucción. |
[editar] Véase también
| [estático] |
construye un objeto en el almacenamiento asignado Original: constructs an object in the allocated storage The text has been machine-translated via Google Translate. You can help to correct and verify the translation. Click here for instructions. (plantilla de función) |
| (hasta C++20) |
Construye un objeto en almacenamiento asignado. (función miembro pública de std::allocator)
|
