std::pmr::polymorphic_allocator<T>:: construct
|
template
<
class
U,
class
...
Args
>
void construct ( U * p, Args && ... args ) ; |
(1) | (depuis C++17) |
|
template
<
class
T1,
class
T2,
class
...
Args1
,
class
...
Args2
>
void
construct
(
std::
pair
<
T1, T2
>
*
p,
|
(2) |
(depuis C++17)
(jusqu'à C++20) |
|
template
<
class
T1,
class
T2
>
void construct ( std:: pair < T1, T2 > * p ) ; |
(3) |
(depuis C++17)
(jusqu'à C++20) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ; |
(4) |
(depuis C++17)
(jusqu'à 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) |
(depuis C++17)
(jusqu'à C++20) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ; |
(6) |
(depuis C++17)
(jusqu'à C++20) |
|
template
<
class
T1,
class
T2,
class
NonPair
>
void construct ( std:: pair < T1, T2 > * p, NonPair && non_pair ) ; |
(7) |
(depuis C++17)
(jusqu'à C++20) |
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 à l'objet construit.
U
au moyen de la
construction uses-allocator
à l'emplacement mémoire non initialisé indiqué par
p
, en utilisant
*
this
comme allocateur.
Cette surcharge participe à la résolution de surcharge seulement si
U
n'est pas une spécialisation de
std::pair
.
(jusqu'à C++20)
|
2)
Premièrement, si l'un des deux
T1
ou
T2
est sensible à l'allocateur, 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 sensible à l'allocateur (
std::
uses_allocator
<
T1, polymorphic_allocator
>
::
value
==
false
) et
std::
is_constructible
<
T1, Args1...
>
::
value
==
true
, alors
xprime
est
x
, inchangé.
2b)
si
T1
est sensible à l'allocateur (
std::
uses_allocator
<
T1, polymorphic_allocator
>
::
value
==
true
), et que son constructeur accepte un tag d'allocateur (
std::
is_constructible
<
T1,
std::
allocator_arg_t
, polymorphic_allocator, Args1...
>
::
value
==
true
), alors
xprime
est
std::
tuple_cat
(
std::
make_tuple
(
std::
allocator_arg
,
*
this
)
, std
::
move
(
x
)
)
.
2c)
si
T1
est allocator-aware (
std::
uses_allocator
<
T1, polymorphic_allocator
>
::
value
==
true
), et que son constructeur prend l'allocateur comme dernier argument (
std::
is_constructible
<
T1, Args1..., polymorphic_allocator
>
::
value
==
true
), alors
xprime
est
std::
tuple_cat
(
std
::
move
(
x
)
,
std::
make_tuple
(
*
this
)
)
.
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)))
7)
Cette surcharge participe à la résolution de surcharge uniquement si, étant donné le modèle de fonction d'exposition uniquement
template< class A, class B > void /*deduce-as-pair*/( const std::pair<A, B>& ); , /*deduce-as-pair*/ ( non_pair ) est mal formé lorsqu'il est considéré comme un opérande non évalué. Équivalent à construct<T1, T2, T1, T2>(p, std::forward<NonPair>(non_pair)); |
(jusqu'à C++20) |
Table des matières |
Paramètres
| p | - | pointeur vers un stockage alloué mais non initialisé |
| 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
|
| non_pair | - |
argument non-
pair
à convertir en
pair
pour une construction ultérieure
|
Valeur de retour
(aucun)
Notes
Cette fonction est appelée (via
std::allocator_traits
) par tout objet compatible avec les allocateurs, tel que
std::pmr::vector
(ou un autre
std::vector
auquel on a fourni un
std::pmr::polymorphic_allocator
comme allocateur à utiliser).
Rapports de défauts
Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.
| DR | Appliqué à | Comportement publié | Comportement correct |
|---|---|---|---|
| LWG 2969 | C++17 |
construction uses-allocator passait
resource()
|
passe * this |
| LWG 2975 | C++17 | la première surcharge était utilisée par erreur pour la construction de paires dans certains cas | contrainte pour ne pas accepter les paires |
| LWG 3525 | C++17 |
aucune surcharge ne pouvait gérer les types non-
pair
convertibles en
pair
|
surcharge de reconstruction ajoutée |
Voir aussi
|
[static]
|
construit un objet dans le stockage alloué
(fonction template) |
|
(until C++20)
|
construit un objet dans le stockage alloué
(fonction membre publique de
std::allocator<T>
)
|