Namensräume
Varianten
Aktionen

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

Von cppreference.com
 
C++
 
Speicherverwaltungsbibliothek
(nur Exposition*)
Algorithmen für uninitialisierten Speicher
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
Beschränkte uninitialisierte
Speicher-Algorithmen
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20) 
(C++20)
C-Bibliothek

Allocatoren
(C++11)
(C++23)
(C++11)
(C++11)
(C++20)
(C++20)
(C++20) 
(C++11)
(C++17)
Speicherressourcen
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
Unterstützung für Garbage Collection
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
(C++11)(bis C++23)
Uninitialisierter Speicher
(bis C++20*)
(bis C++20*)
(bis C++20*)
Explizites Lebenszeitmanagement
(C++23)(C++23)
 
std::scoped_allocator_adaptor
 
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 construct( 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)
Hilfs-Funktionale
template < class T, class... Args >
std::tuple</* siehe unten */> /*concat-args*/( std::tuple<Args...>&& tup );
 (7) (nur Exposition*)
(bis C++20)

Konstruiert ein Objekt im zugewiesenen, aber noch nicht initialisierten Speicher, auf den von p gezeigt wird, unter Verwendung des äußeren Allocators und der bereitgestellten Konstruktorargumente. Wenn das Objekt von einem Typ ist, der selbst Allocatoren verwendet, oder wenn es ein std::pair ist(bis C++20), wird der innere Allocator an das konstruierte Objekt weitergegeben.

1) Konstruiert ein Objekt vom Typ T durch Uses-Allocator-Konstruktion an der uninitialisierten Speicherstelle, die von p angegeben wird, unter Verwendung des äußersten Allocators.

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

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

 (bis C++20)

Äquivalent zu 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 uninitialisierten Speicherstelle, die von p angegeben wird, unter Verwendung des äußersten Allocators.
2) Sei xprime concat-args <T1>(std::move(x)), yprime concat-args <T2>(std::move(y)), ruft outermost-construct (p, std::piecewise_construct, std::move(xprime), std::move(yprime)) auf.
3) Äquivalent zu construct(p, std::piecewise_construct, std::tuple<>(), std::tuple<>());.
4-6) Äquivalent zu 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) Fasst 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

Inhalt

[bearbeiten] Parameter

p - Zeiger auf zugewiesenen, aber nicht initialisierten Speicher
args - die Konstruktorargumente, die an den Konstruktor von T übergeben werden sollen
x - die Konstruktorargumente, die an den Konstruktor von T1 übergeben werden sollen
y - die Konstruktorargumente, die an den Konstruktor von T2 übergeben werden sollen
xy - das Paar, dessen zwei Member die Konstruktorargumente für T1 und T2 sind
tup - die zu kombinierenden Argumente

[bearbeiten] Hinweise

Diese Funktion wird (über std::allocator_traits) von jedem allocator-bewussten Objekt, wie z.B. std::vector, aufgerufen, dem ein std::scoped_allocator_adaptor als zu verwendender Allocator übergeben wurde. Da inner_allocator_type selbst eine Spezialisierung von std::scoped_allocator_adaptor ist, wird diese Funktion auch dann aufgerufen, wenn die durch diese Funktion konstruierten allocator-bewussten Objekte beginnen, ihre eigenen Member zu konstruieren.

[bearbeiten] 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 Allocatoren wurden durch Wertinitialisierung erhalten
ein inner_allocator_type-Objekt		 erhalten durch Aufruf von inner_allocator()
LWG 2511
(P0475R1)		 C++11 concat-args könnte Elemente von std::tuples kopieren alle Elementkopieroperationen eliminiert
LWG 2586 C++11 nur Konstruktionen von
inner_allocator_type rvalues wurden geprüft		 prüft Konstruktionen von nicht-const
inner_allocator_type lvalues stattdessen
LWG 2975 C++11 Überladung (1) war nicht eingeschränkt eingeschränkt, um std::pair abzulehnen

[bearbeiten] Siehe auch

[static]
 konstruiert ein Objekt im allozierten Speicher
(function template) [edit]
(bis C++20)
 konstruiert ein Objekt im allokierten Speicher
(öffentliche Memberfunktion von std::allocator<T>) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/memory/scoped_allocator_adaptor/construct&oldid=177662"