Namespaces
Variants

std::scoped_allocator_adaptor<OuterAlloc,InnerAlloc...>:: construct

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::scoped_allocator_adaptor
**Übersetzungsdetails:** - `construct` → `konstruiere` (fachgerechte Übersetzung für C++ Kontext) - `until` → `bis` (zeitliche Angabe) - HTML-Tags, Attribute und Code-Blöcke wurden unverändert belassen - C++-spezifische Begriffe (template, class, void, std::pair, etc.) wurden nicht übersetzt - Formatierung und Struktur vollständig erhalten (Anmerkung: Der bereitgestellte HTML-Code enthält keinen übersetzbaren Text, da alle Tags und Attribute gemäß den Anweisungen unverändert bleiben sollen und die Tabellenzellen leer sind.)
Definiert in Header <scoped_allocator>
template < class T, class ... Args >
void construct ( T * p, Args && ... args ) ;
(1)
template < class T1, class T2, class ... Args1 , class ... Args2 >

void konstruiere ( std:: pair < T1, T2 > * p, std:: piecewise_construct_t ,

std:: tuple < Args1... > x, std:: tuple < Args2... > y ) ;
(2) (bis C++20)
template < class T1, class T2 >
void construct ( std:: pair < T1, T2 > * p ) ;
(3) (bis C++20)
template < class T1, class T2, class U, class V >
void construct ( std:: pair < T1, T2 > * p, U && x, V && y ) ;
(4) (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) (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) (bis C++20)
Hilfsfunktions-Templates
template < class T, class ... Args >
std:: tuple < /* siehe unten */ > /*concat-args*/ ( std:: tuple < Args... > && tup ) ;
(7) ( Nur zur Darstellung* )
(bis C++20)

Konstruiert ein Objekt im allokierten, aber nicht initialisierten Speicher, auf den p zeigt, unter Verwendung des äußeren Allokators und der bereitgestellten Konstruktorargumente. Wenn das Objekt von einem Typ ist, der selbst Allokatoren verwendet , oder wenn es sich um std::pair (bis C++20) handelt, wird der innere Allokator an das konstruierte Objekt weitergegeben.

1) Constructs an object of type T by Uses-Allocator-Konstruktion at the uninitialized memory location indicated by p using the outermost allocator.

Gegeben std:: uses_allocator < T, inner_allocator_type > :: value als uses_inner :

Diese Überladung nimmt nur dann an der Überladungsauflösung teil, wenn T keine Spezialisierung von std::pair ist.

(bis C++20)

Entspricht std:: apply
(
[ p, this ] ( auto && ... newargs )
{
outermost-construct
( p, std:: forward < decltype ( newargs ) > ( newargs ) ... ) ;
} ,
std:: uses_allocator_construction_args
( inner_allocator ( ) , std:: forward < Args > ( args ) ... )
) ; .

(seit C++20)
2-6) Konstruiert ein std::pair -Objekt durch Uses-allocator-Konstruktion an der nicht initialisierten Speicherstelle, die durch p angegeben wird, unter Verwendung des äußersten Allokators.
2) Sei xprime gleich concat-args  < T1 > ( std :: move ( x ) ) , yprime gleich concat-args  < T2 > ( std :: move ( y ) ) , ruft outermost-construct  ( p, std:: piecewise_construct , std :: move ( xprime ) , std :: move ( yprime ) ) auf.
3) Entspricht construct ( p, std:: piecewise_construct , std:: tuple <> ( ) , std:: tuple <> ( ) ) ; .
4-6) Entspricht construct ( p, std:: piecewise_construct ,
std:: forward_as_tuple ( xarg ) , std:: forward_as_tuple ( yarg ) ) ; , wobei xarg und yarg wie folgt definiert sind:
Überladung xarg yarg
(4) std:: forward < U > ( x ) std:: forward < V > ( y )
(5) xy. first xy. second
(6) std:: forward < U > ( xy. first ) std:: forward < V > ( xy. second )
7) Führt die in tup enthaltenen Argumente und zusätzliche Argumente zusammen, die für die Uses-allocator-Konstruktion eines Objekts vom Typ T erforderlich sind.
Gegeben std:: uses_allocator < T, inner_allocator_type > :: value als uses_inner :

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
tup - die zusammenzuführenden Argumente

Hinweise

Diese Funktion wird (über std::allocator_traits ) von jedem allocator-aware Objekt aufgerufen, wie z.B. std::vector , dem ein std::scoped_allocator_adaptor als zu verwendender Allokator gegeben wurde. Da inner_allocator_type selbst eine Spezialisierung von std::scoped_allocator_adaptor ist, wird diese Funktion auch aufgerufen, wenn die durch diese Funktion konstruierten allocator-aware Objekte mit der Konstruktion ihrer eigenen Member beginnen.

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2203 C++11 innere Allokatoren wurden durch Wertinitialisierung
eines inner_allocator_type Objekts erhalten 		erhalten durch Aufruf von inner_allocator()
LWG 2511
( P0475R1 ) 		C++11 concat-args könnte Elemente von std::tuple kopieren eliminierte alle Elementkopiervorgänge
LWG 2586 C++11 nur Konstruktionen aus
inner_allocator_type Rvalues wurden geprüft 		prüft stattdessen Konstruktionen aus nicht-konstanten
inner_allocator_type Lvalues
LWG 2975 C++11 Überladung (1) war nicht eingeschränkt eingeschränkt um std::pair abzulehnen

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> )