std::pmr::polymorphic_allocator<T>:: construct
|
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) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, const std:: pair < U, V > & xy ) ; |
(5) |
(desde C++17)
(hasta C++20) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ; |
(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 apuntado por p con los argumentos del constructor proporcionados. Si el objeto es de un tipo que utiliza allocators, o si es std::pair, pasa * this al objeto construido.
U
mediante
construcción uses-allocator
en la ubicación de memoria no inicializada indicada por
p
, utilizando
*
this
como el asignador de memoria.
Esta sobrecarga participa en la resolución de sobrecarga solo si
U
no es una especialización de
std::pair
.
(hasta C++20)
|
2)
Primero, si cualquiera de
T1
o
T2
es consciente del asignador, modifica las tuplas
x
y
y
para incluir
this->resource()
, resultando en las dos nuevas tuplas
xprime
y
yprime
, de acuerdo con las siguientes tres reglas:
2a)
si
T1
no es consciente del 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 del 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 del 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 el reemplazo de
y
con
yprime
.
Una vez que
xprime
y
yprime
están construidos, construye el par
p
en el almacenamiento asignado como si fuera mediante
::
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 de miembros del par 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 participa en la resolución de sobrecarga solo si se proporciona la plantilla de función de solo exposición
template< class A, class B > void /*deduce-as-pair*/( const std::pair<A, B>& ); , /*deduce-as-pair*/ ( 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) |
Contenidos |
Parámetros
| p | - | puntero a 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 par cuyos dos miembros son los argumentos del constructor para
T1
y
T2
|
| non_pair | - |
argumento no-
pair
para convertir a
pair
para construcción adicional
|
Valor de retorno
(ninguno)
Notas
Esta función es llamada (a través de
std::allocator_traits
) por cualquier objeto consciente del asignador, como
std::pmr::vector
(u otro
std::vector
al que se le haya proporcionado un
std::pmr::polymorphic_allocator
como asignador a utilizar).
Informes de defectos
Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.
| DR | Aplicado a | Comportamiento publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 2969 | C++17 |
la construcción uses-allocator pasaba
resource()
|
pasa * this |
| LWG 2975 | C++17 | la primera sobrecarga se usaba incorrectamente para construcción de pair en algunos casos | restringida para no aceptar pairs |
| LWG 3525 | C++17 |
ninguna sobrecarga podía manejar tipos no-
pair
convertibles a
pair
|
añadida sobrecarga de reconstrucción |
Véase también
|
[static]
|
construye un objeto en el almacenamiento asignado
(plantilla de función) |
|
(until C++20)
|
construye un objeto en almacenamiento asignado
(función miembro pública de
std::allocator<T>
)
|