std::experimental::pmr::polymorphic_allocator<T>:: construct
|
template
<
class
U,
class
...
Args
>
void construct ( U * p, Args && ... args ) ; |
(1) | (Bibliothek Fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
...
Args1
,
class
...
Args2
>
void
construct
(
std::
pair
<
T1, T2
>
*
p,
|
(2) | (Bibliothek Fundamentals TS) |
|
template
<
class
T1,
class
T2
>
void construct ( std:: pair < T1, T2 > * p ) ; |
(3) | (Bibliothek Fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ; |
(4) | (Bibliothek 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) | (Bibliothek Fundamentals TS) |
|
template
<
class
T1,
class
T2,
class
U,
class
V
>
void construct ( std:: pair < T1, T2 > * p, std:: pair < U, V > && xy ) ; |
(6) | (Bibliothek Fundamentals TS) |
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 std::pair ist, wird
this->resource()
an das konstruierte Objekt weitergegeben.
1) Wenn
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
false
(der Typ
U
verwendet keine Allokatoren) und
std::
is_constructible
<
U, Args...
>
::
value
==
true
, dann konstruiert das Objekt wie durch
::
new
(
(
void
*
)
p
)
U
(
std::
forward
<
Args
>
(
args
)
...
)
;
.
Andernfalls, falls
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
true
(der Typ
U
verwendet Allokatoren, z.B. ist es ein Container) und
std::
is_constructible
<
U,
std::
allocator_arg_t
, memory_resource
*
, Args...
>
::
value
==
true
, dann konstruiert das Objekt wie durch
::
new
(
(
void
*
)
p
)
U
(
std::
allocator_arg
, this
-
>
resource
(
)
,
std::
forward
<
Args
>
(
args
)
...
)
;
.
Andernfalls, falls
std::
uses_allocator
<
U, memory_resource
*
>
::
value
==
true
(der Typ
U
verwendet Allokatoren, z.B. ist es ein Container) und
std::
is_constructible
<
U, Args..., memory_resource
*
>
::
value
==
true
, dann konstruiert das Objekt wie durch
::
new
(
(
void
*
)
p
)
U
(
std::
forward
<
Args
>
(
args
)
..., this
-
>
resource
(
)
)
;
.
Andernfalls ist das Programm fehlerhaft.
2) Zuerst, falls 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, memory_resource
*
>
::
value
==
false
) und
std::
is_constructible
<
T1, Args1...
>
::
value
==
true
, dann ist
xprime
unverändert
x
.
2b) wenn
T1
allocator-aware ist (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
true
), und sein Konstruktor einen Allocator-Tag akzeptiert (
std::
is_constructible
<
T1,
std::
allocator_arg_t
, memory_resource
*
, Args1...
>
::
value
==
true
), dann ist
xprime
std::
tuple_cat
(
std::
make_tuple
(
std::
allocator_arg
, this
-
>
resource
(
)
)
, std
::
move
(
x
)
)
.
2c) falls
T1
allocator-aware ist (
std::
uses_allocator
<
T1, memory_resource
*
>
::
value
==
true
) und sein Konstruktor den Allokator als letztes Argument akzeptiert (
std::
is_constructible
<
T1, Args1..., memory_resource
*
>
::
value
==
true
), dann ist
xprime
std::
tuple_cat
(
std
::
move
(
x
)
,
std::
make_tuple
(
this
-
>
resource
(
)
)
)
.
2d) Andernfalls ist das Programm fehlerhaft.
Gleiche Regeln gelten für
T2
und den Ersatz von
y
mit
yprime
.
Sobald
xprime
und
yprime
konstruiert wurden, wird das Paar
p
im allokierten Speicher konstruiert, 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 Speicherressource 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
)
)
)
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 Elemente die Konstruktorargumente für
T1
und
T2
sind
|
Rückgabewert
(keine)
Hinweise
Diese Funktion wird (über
std::allocator_traits
) von jedem allocator-aware Objekt aufgerufen, wie z.B.
std::vector
, dem ein
std::polymorphic_allocator
als zu verwendender Allokator gegeben wurde. Da
memory_resource*
implizit zu
polymorphic_allocator
konvertiert, wird der memory_resource-Zeiger an alle allocator-aware Unterobjekte weitergegeben, die polymorphe Allokatoren verwenden.
Siehe auch
|
[static]
|
Konstruiert ein Objekt im allozierten Speicher
(Funktions-Template) |
|
(bis C++20)
|
Konstruiert ein Objekt im allozierten Speicher
(Öffentliche Elementfunktion von
std::allocator<T>
)
|