std::experimental::pmr::polymorphic_allocator<T>:: construct
|
template
<
class
U,
class
...
Args
>
void construct ( U * p, Args && ... args ) ; |
(1) | (spécifications techniques des bibliothèques fondamentales) |
|
template
<
class
T1,
class
T2,
class
...
Args1
,
class
...
Args2
>
void
construct
(
std::
pair
<
T1, T2
>
*
p,
|
(2) | (spécifications techniques des bibliothèques fondamentales) |
|
template
<
class
T1,
class
T2
>
void construct ( std:: pair < T1, T2 > * p ) ; |
(3) | (spécifications techniques des bibliothèques fondamentales) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ; |
(4) | (spécifications techniques des bibliothèques fondamentales) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, const std:: pair < U, V > & xy ) ; |
(5) | (spécifications techniques des bibliothèques fondamentales) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ; |
(6) | (spécifications techniques des bibliothèques fondamentales) |
Construit un objet dans un stockage alloué mais non initialisé pointé par
p
avec les arguments de constructeur fournis. Si l'objet est d'un type qui utilise lui-même des allocateurs, ou s'il s'agit de std::pair, transmet
this->resource()
à l'objet construit.
1) Si
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
false
(le type
U
n'utilise pas d'allocateurs) et
std::
is_constructible
<
U, Args...
>
::
value
==
true
, alors construit l'objet comme par
::
new
(
(
void
*
)
p
)
U
(
std::
forward
<
Args
>
(
args
)
...
)
;
.
Sinon, si
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
true
(le type
U
utilise des allocateurs, par exemple c'est un conteneur) et
std::
allocator_arg_t
, memory_resource
*
, Args...
>
::
value
==
true
, alors construit l'objet comme par
::
new
(
(
void
*
)
p
)
U
(
std::
allocator_arg
, this
-
>
resource
(
)
,
std::
forward
<
Args
>
(
args
)
...
)
;
.
Sinon, si
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
true
(le type
U
utilise des allocateurs, par exemple c'est un conteneur) et
std::
is_constructible
<
U, Args..., memory_resource
*
>
::
value
==
true
, alors construit l'objet comme par
::
new
(
(
void
*
)
p
)
U
(
std::
forward
<
Args
>
(
args
)
..., this
-
>
resource
(
)
)
;
.
Sinon, le programme est mal formé.
2) Premièrement, si l'un des deux
T1
ou
T2
est allocator-aware, modifie les tuples
x
et
y
pour inclure
this->resource()
, résultant en deux nouveaux tuples
xprime
et
yprime
, selon les trois règles suivantes :
2a) si
T1
n'est pas allocator-aware (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
false
) et que
std::
is_constructible
<
T1, Args1...
>
::
value
==
true
, alors
xprime
est
x
, inchangé.
2b) si
T1
est sensible à l'allocateur (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
true
), et que son constructeur accepte un tag d'allocateur (
std::
is_constructible
<
T1,
std::
allocator_arg_t
, memory_resource
*
, Args1...
>
::
value
==
true
), alors
xprime
est
std::
tuple_cat
(
std::
make_tuple
(
std::
allocator_arg
, this
-
>
resource
(
)
)
, std
::
move
(
x
)
)
.
2c) si
T1
est sensible à l'allocateur (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
true
), et que son constructeur prend l'allocateur comme dernier argument (
std::
is_constructible
<
T1, Args1..., memory_resource
*
>
::
value
==
true
), alors
xprime
est
std::
tuple_cat
(
std
::
move
(
x
)
,
std::
make_tuple
(
this
-
>
resource
(
)
)
)
.
2d) Sinon, le programme est mal formé.
Les mêmes règles s'appliquent à
T2
et au remplacement de
y
par
yprime
.
Une fois que
xprime
et
yprime
sont construits, construit la paire
p
dans le stockage alloué comme si par
::
new
(
(
void
*
)
p
)
pair
<
T1, T2
>
(
std::
piecewise_construct
, std
::
move
(
xprime
)
, std
::
move
(
yprime
)
)
;
.
3) Équivalent à construct ( p, std:: piecewise_construct , std:: tuple <> ( ) , std:: tuple <> ( ) ) , c'est-à-dire qu'il transmet la ressource mémoire aux types membres de la paire s'ils les acceptent.
4) Équivalent à
construct
(
p,
std::
piecewise_construct
,
std::
forward_as_tuple
(
std::
forward
<
U
>
(
x
)
)
,
std::
forward_as_tuple
(
std::
forward
<
V
>
(
y
)
)
)
5) Équivalent à
construct
(
p,
std::
piecewise_construct
,
std::
forward_as_tuple
(
xy.
first
)
,
std::
forward_as_tuple
(
xy.
second
)
)
6) Équivalent à
construct
(
p,
std::
piecewise_construct
,
std::
forward_as_tuple
(
std::
forward
<
U
>
(
xy.
first
)
)
,
std::
forward_as_tuple
(
std::
forward
<
V
>
(
xy.
second
)
)
)
Table des matières |
Paramètres
| p | - | pointeur vers une zone mémoire allouée mais non initialisée |
| args... | - |
les arguments du constructeur à passer au constructeur de
T
|
| x | - |
les arguments du constructeur à passer au constructeur de
T1
|
| y | - |
les arguments du constructeur à passer au constructeur de
T2
|
| xy | - |
la paire dont les deux membres sont les arguments du constructeur pour
T1
et
T2
|
Valeur de retour
(aucun)
Notes
Cette fonction est appelée (via
std::allocator_traits
) par tout objet sensible aux allocateurs, tel que
std::vector
, auquel on a fourni un
std::polymorphic_allocator
comme allocateur à utiliser. Étant donné que
memory_resource*
se convertit implicitement en
polymorphic_allocator
, le pointeur de ressource mémoire se propagera à tout sous-objet sensible aux allocateurs utilisant des allocateurs polymorphes.
Voir aussi
|
[static]
|
construit un objet dans le stockage alloué
(modèle de fonction) |
|
(jusqu'en C++20)
|
construit un objet dans le stockage alloué
(fonction membre publique de
std::allocator<T>
)
|