std::experimental::pmr::polymorphic_allocator<T>:: construct
|
template
<
class
U,
class
...
Args
>
void construct ( U * p, Args && ... args ) ; |
(1) | (biblioteca fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
...
Args1
,
class
...
Args2
>
void
construct
(
std::
pair
<
T1, T2
>
*
p,
|
(2) | (biblioteca fundamentals TS) |
|
template
<
class
T1,
class
T2
>
void construct ( std:: pair < T1, T2 > * p ) ; |
(3) | (biblioteca fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ; |
(4) | (biblioteca fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, const std:: pair < U, V > & xy ) ; |
(5) | (biblioteca fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ; |
(6) | (biblioteca fundamentals TS) |
Construye un objeto en almacenamiento asignado pero no inicializado apuntado por
p
con los argumentos del constructor proporcionados. Si el objeto es de un tipo que utiliza asignadores, o si es std::pair, pasa
this->resource()
al objeto construido.
1) Si
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
false
(el tipo
U
no utiliza asignadores) y
std::
is_constructible
<
U, Args...
>
::
value
==
true
, entonces construye el objeto como si fuera mediante
::
new
(
(
void
*
)
p
)
U
(
std::
forward
<
Args
>
(
args
)
...
)
;
.
De lo contrario, si
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
true
(el tipo
U
utiliza asignadores, por ejemplo, es un contenedor) y
std::
is_constructible
<
U,
std::
allocator_arg_t
, memory_resource
*
, Args...
>
::
value
==
true
, entonces construye el objeto como si fuera mediante
::
new
(
(
void
*
)
p
)
U
(
std::
allocator_arg
, this
-
>
resource
(
)
,
std::
forward
<
Args
>
(
args
)
...
)
;
.
De lo contrario, si
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
true
(el tipo
U
utiliza asignadores, por ejemplo, es un contenedor) y
std::
is_constructible
<
U, Args..., memory_resource
*
>
::
value
==
true
, entonces construye el objeto como si fuera mediante
::
new
(
(
void
*
)
p
)
U
(
std::
forward
<
Args
>
(
args
)
..., this
-
>
resource
(
)
)
;
.
De lo contrario, el programa está mal formado.
2) Primero, si cualquiera de
T1
o
T2
es allocator-aware, 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, memory_resource
*
>
::
value
==
false
) y
std::
is_constructible
<
T1, Args1...
>
::
value
==
true
, entonces
xprime
es
x
, sin modificar.
2b) si
T1
es allocator-aware (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
true
), y su constructor toma una etiqueta de asignador (
std::
is_constructible
<
T1,
std::
allocator_arg_t
, memory_resource
*
, Args1...
>
::
value
==
true
), entonces
xprime
es
std::
tuple_cat
(
std::
make_tuple
(
std::
allocator_arg
, this
-
>
resource
(
)
)
, std
::
move
(
x
)
)
.
2c) si
T1
es consciente del asignador (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
true
), y su constructor toma el asignador como último argumento (
std::
is_constructible
<
T1, Args1..., memory_resource
*
>
::
value
==
true
), entonces
xprime
es
std::
tuple_cat
(
std
::
move
(
x
)
,
std::
make_tuple
(
this
-
>
resource
(
)
)
)
.
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
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, transmite el recurso de memoria a los tipos 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
)
)
)
Contenidos |
Parámetros
| p | - | puntero a almacenamiento asignado pero no inicializado |
| args... | - |
los argumentos del constructor que se pasarán al constructor de
T
|
| x | - |
los argumentos del constructor que se pasarán al constructor de
T1
|
| y | - |
los argumentos del constructor que se pasarán al constructor de
T2
|
| xy | - |
el par cuyos dos miembros son los argumentos del constructor para
T1
y
T2
|
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::vector
, al que se le haya proporcionado un
std::polymorphic_allocator
como asignador a utilizar. Dado que
memory_resource*
se convierte implícitamente a
polymorphic_allocator
, el puntero del recurso de memoria se propagará a cualquier subobjeto consciente del asignador que utilice asignadores polimórficos.
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>
)
|