std::experimental::pmr::polymorphic_allocator<T>::konstruieren
| template< class U, class... Args > void construct( U* p, Args&&... args ); |
(1) | (library fundamentals TS) |
| template< class T1, class T2, class... Args1, class... Args2 > void konstruieren( std::pair<T1, T2>* p, |
(2) | (library fundamentals TS) |
| template< class T1, class T2 > void konstruieren( std::pair<T1, T2>* p ); |
(3) | (library fundamentals TS) |
| template< class T1, class T2, class U, class V > void konstruieren( std::pair<T1, T2>* p, U&& x, V&& y ); |
(4) | (library fundamentals TS) |
| (5) | (library fundamentals TS) | |
| (6) | (library fundamentals TS) | |
Konstruiert ein Objekt im zugewiesenen, aber nicht initialisierten Speicher, auf den von p gezeigt wird, unter Verwendung der bereitgestellten Konstruktorargumente. Wenn das Objekt von einem Typ ist, der selbst Allocatoren verwendet, oder wenn es sich um `std::pair` handelt, wird `this->resource()` an das konstruierte Objekt weitergegeben.
1) Wenn std::uses_allocator<U, memory_resource*>::value == false (der Typ U verwendet keine Allocatoren) und std::is_constructible<U, Args...>::value == true, dann wird das Objekt konstruiert, als ob es ::new((void *) p) U(std::forward<Args>(args)...); wäre.
Andernfalls, wenn std::uses_allocator<U, memory_resource*>::value == true (der Typ U verwendet Allocatoren, z. B. ist es ein Container) und std::is_constructible<U, std::allocator_arg_t, memory_resource*, Args...>::value == true, dann wird das Objekt konstruiert, als ob es ::new((void *) p) U(std::allocator_arg, this->resource(), std::forward<Args>(args)...); wäre.
Andernfalls, wenn std::uses_allocator<U, memory_resource*>::value == true (der Typ U verwendet Allocatoren, z. B. ist es ein Container) und std::is_constructible<U, Args..., memory_resource*>::value == true, dann wird das Objekt konstruiert, als ob es ::new((void *) p) U(std::forward<Args>(args)..., this->resource()); wäre.
Andernfalls ist das Programm fehlerhaft.
2) Zuerst, wenn entweder T1 oder T2 allocator-aware ist, werden die Tupel x und y modifiziert, um this->resource() einzuschließen, was zu den beiden 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 x, unverändert.
2b) Wenn T1 allocator-aware ist (std::uses_allocator<T1, memory_resource*>::value == true) und sein Konstruktor ein Allocator-Tag annimmt (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) Wenn T1 allocator-aware ist (std::uses_allocator<T1, memory_resource*>::value == true) und sein Konstruktor den Allocator als letztes Argument annimmt (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 ill-formed.
Dasselbe gilt für T2 und den Ersatz von y durch yprime.
Nachdem xprime und yprime konstruiert wurden, wird das Paar p im zugewiesenen Speicher konstruiert, als ob es ::new((void *) p) pair<T1, T2>(std::piecewise_construct, std::move(xprime), std::move(yprime)); wäre.
3) Äquivalent zu konstruieren(p, std::piecewise_construct, std::tuple<>(), std::tuple<>()), d. h. die Weitergabe der Speicherressource an die Mitgliedstypen des Paares, falls diese sie akzeptieren.
4) Äquivalent zu
konstruieren(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(x)),
std::forward_as_tuple(std::forward<V>(y)))
5) Äquivalent zu
konstruieren(p, std::piecewise_construct, std::forward_as_tuple(xy.first),
std::forward_as_tuple(xy.second))
6) Äquivalent zu
konstruieren(p, std::piecewise_construct, std::forward_as_tuple(std::forward<U>(xy.first)),
std::forward_as_tuple(std::forward<V>(xy.second)))
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 |
[bearbeiten] Rückgabewert
(keine)
[bearbeiten] 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 Allocator übergeben wurde. Da sich memory_resource* implizit in polymorphic_allocator konvertiert, wird der Speicherressourcenzeiger an alle allocator-aware Unterobjekte weitergegeben, die polymorphe Allocatoren verwenden.
[bearbeiten] Siehe auch
| [static] |
konstruiert ein Objekt im allozierten Speicher (function template) |
| (bis C++20) |
konstruiert ein Objekt im allokierten Speicher (öffentliche Memberfunktion von std::allocator<T>) |
