std::pmr::polymorphic_allocator<T>:: construct
|
template
<
class
U,
class
...
Args
>
void construct ( U * p, Args && ... args ) ; |
(1) | (seit C++17) |
|
template
<
class
T1,
class
T2,
class
...
Args1
,
class
...
Args2
>
void
construct
(
std::
pair
<
T1, T2
>
*
p,
|
(2) |
(seit C++17)
(bis C++20) |
|
template
<
class
T1,
class
T2
>
void construct ( std:: pair < T1, T2 > * p ) ; |
(3) |
(seit C++17)
(bis C++20) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ; |
(4) |
(seit C++17)
(bis 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) |
(seit C++17)
(bis C++20) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ; |
(6) |
(seit C++17)
(bis C++20) |
|
template
<
class
T1,
class
T2,
class
NonPair
>
void construct ( std:: pair < T1, T2 > * p, NonPair && non_pair ) ; |
(7) |
(seit C++17)
(bis C++20) |
Konstruiert ein Objekt im allokierten, aber nicht initialisierten Speicher, auf den p zeigt, mit den bereitgestellten Konstruktorargumenten. Wenn das Objekt vom Typ ist, der selbst Allokatoren verwendet, oder wenn es sich um std::pair handelt, wird * this an das konstruierte Objekt weitergegeben.
U
mittels
Uses-allocator-Konstruktion
an der nicht initialisierten Speicherstelle, die durch
p
angegeben ist, unter Verwendung von
*
this
als Allokator.
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn
U
keine Spezialisierung von
std::pair
ist.
(bis C++20)
|
2)
Zuerst, wenn entweder
T1
oder
T2
allocator-aware ist, modifiziert die Tupel
x
und
y
um
this->resource()
einzubeziehen, was zu den zwei neuen Tupeln
xprime
und
yprime
führt, gemäß den folgenden drei Regeln:
2a)
wenn
T1
nicht allocator-aware ist (
std::
uses_allocator
<
T1, polymorphic_allocator
>
::
value
==
false
) und
std::
is_constructible
<
T1, Args1...
>
::
value
==
true
, dann ist
xprime
x
, unverändert.
2b)
wenn
T1
allocator-aware ist (
std::
uses_allocator
<
T1, polymorphic_allocator
>
::
value
==
true
), und dessen Konstruktor einen Allocator-Tag akzeptiert (
std::
is_constructible
<
T1,
std::
allocator_arg_t
, polymorphic_allocator, Args1...
>
::
value
==
true
), dann ist
xprime
std::
tuple_cat
(
std::
make_tuple
(
std::
allocator_arg
,
*
this
)
, std
::
move
(
x
)
)
.
2c)
wenn
T1
allocator-aware ist (
std::
uses_allocator
<
T1, polymorphic_allocator
>
::
value
==
true
) und dessen Konstruktor den Allokator als letztes Argument akzeptiert (
std::
is_constructible
<
T1, Args1..., polymorphic_allocator
>
::
value
==
true
), dann ist
xprime
std::
tuple_cat
(
std
::
move
(
x
)
,
std::
make_tuple
(
*
this
)
)
.
2d)
Andernfalls ist das Programm fehlerhaft.
Gleiche Regeln gelten für
T2
und den Ersatz von
y
mit
yprime
.
Sobald
xprime
und
yprime
konstruiert sind, konstruiert das Paar
p
im allokierten Speicher als ob durch
::
new
(
(
void
*
)
p
)
pair
<
T1, T2
>
(
std::
piecewise_construct
, std
::
move
(
xprime
)
, std
::
move
(
yprime
)
)
;
.
3)
Entspricht
construct
(
p,
std::
piecewise_construct
,
std::
tuple
<>
(
)
,
std::
tuple
<>
(
)
)
, das heißt, gibt die Memory-Ressource an die Membertypen des Paares weiter, falls diese sie akzeptieren.
4)
Entspricht
construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(x)), std::forward_as_tuple(std::forward<V>(y)))
5)
Entspricht
construct(p, std::piecewise_construct, std::forward_as_tuple(xy.first), std::forward_as_tuple(xy.second))
6)
Entspricht
construct(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(xy.first)), std::forward_as_tuple(std::forward<V>(xy.second)))
7)
Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn die nur zur Darstellung dienende Funktionsvorlage
template< class A, class B > void /*deduce-as-pair*/( const std::pair<A, B>& ); , /*deduce-as-pair*/ ( non_pair ) als nicht ausgewerteter Operand fehlerhaft ist. Äquivalent zu construct<T1, T2, T1, T2>(p, std::forward<NonPair>(non_pair)); |
(bis C++20) |
Inhaltsverzeichnis |
Parameter
| p | - | Zeiger auf allokierten, aber nicht initialisierten Speicher |
| args... | - |
die Konstruktorargumente, die an den Konstruktor von
T
übergeben werden
|
| x | - |
die Konstruktorargumente, die an den Konstruktor von
T1
übergeben werden
|
| y | - |
die Konstruktorargumente, die an den Konstruktor von
T2
übergeben werden
|
| xy | - |
das Paar, dessen zwei Mitglieder die Konstruktorargumente für
T1
und
T2
sind
|
| non_pair | - |
Nicht-
pair
Argument, das in ein
pair
konvertiert wird für die weitere Konstruktion
|
Rückgabewert
(keine)
Hinweise
Diese Funktion wird (über
std::allocator_traits
) von jedem allocator-aware Objekt aufgerufen, wie z.B.
std::pmr::vector
(oder einem anderen
std::vector
dem ein
std::pmr::polymorphic_allocator
als zu verwendender Allokator übergeben wurde).
Fehlerberichte
Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.
| DR | Angewendet auf | Verhalten wie veröffentlicht | Korrektes Verhalten |
|---|---|---|---|
| LWG 2969 | C++17 |
Uses-allocator-Konstruktion übergab
resource()
|
übergibt * this |
| LWG 2975 | C++17 | erste Überladung wurde fälschlicherweise für Paar-Konstruktion in einigen Fällen verwendet | eingeschränkt, um Paare nicht zu akzeptieren |
| LWG 3525 | C++17 |
keine Überladung konnte Nicht-
pair
-Typen verarbeiten, die in
pair
konvertierbar sind
|
rekonstruierende Überladung hinzugefügt |
Siehe auch
|
[static]
|
Konstruiert ein Objekt im allozierten Speicher
(Funktions-Template) |
|
(until C++20)
|
Konstruiert ein Objekt im allozierten Speicher
(öffentliche Elementfunktion von
std::allocator<T>
)
|