CKTIS / C++
Placement new: Konstruktion in vorhandenem Speicher
Konstruiere ein Objekt in einem vorbereiteten Speicherplatz, verwalte seine Lebensdauer getrennt vom Speicher und untersage das Kopieren und Verschieben des Besitzers.
Version: ISO C++23; implementation support may vary
Syntax
#include <new>
// Assumes overload resolution selects the standard non-allocating placement overload.
T* p = ::new (static_cast<void*>(storage)) T(args...); // Construct one T in existing storage.
p->~T(); // Destroy that T without freeing the storage.
// Inside the owning class, disable copying and moving:
Owner(const Owner&) = delete;
Owner& operator=(const Owner&) = delete;
Owner(Owner&&) = delete;
Owner& operator=(Owner&&) = delete;In C++23 konstruiert ::new (static_cast<void*>(storage)) T(args...) ein T an der angegebenen Adresse und liefert T*, wenn die nicht allokierende Standardüberladung operator new(std::size_t, void*) aus <new> ausgewählt wird. Diese globale Überladung gibt nur die Adresse zurück. Das führende :: umgeht die Suche im Klassenbereich, aber die Umwandlung in void* garantiert nicht die Auswahl der Standardüberladung. Gilt alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, berücksichtigt die Überladungsauflösung zunächst ein zusätzliches Argument vom Typ std::align_val_t. Daher kann stattdessen eine passende globale Placement-Überladung mit Ausrichtungsargument ausgewählt werden. Wird keine passende Allokationsfunktion gefunden, wird die Überladungsauflösung ohne das Ausrichtungsargument wiederholt. Gewöhnliches allokierendes new T(args...) beschafft Speicher und initialisiert das Objekt. Andere Placement-Überladungen können Speicher allokieren.
Übergib eine gültige Adresse ungleich null mit mindestens sizeof(T) verfügbaren Bytes und einer Ausrichtung gemäß alignof(T). Im Beispiel gewährleistet alignas(Item) die Ausrichtung. Die Lebensdauer des konstruierten Objekts beginnt nach erfolgreicher Initialisierung. Wirft der Konstruktor eine Ausnahme, gibt das passende Standard-Placement-operator delete(void*, void*) keinen Speicher frei. Markiere den Speicherplatz erst nach erfolgreicher Konstruktion als belegt.
Bewahre den vom New-Ausdruck gelieferten T* auf. Eine Typumwandlung allein konstruiert kein Objekt, und dieselbe Adresse erlaubt keinen Zugriff über einen inkompatiblen Typ (Strict Aliasing). std::launder kann einen Zeiger auf ein bereits lebendes Objekt ähnlichen Typs an dieser Adresse liefern, wenn die Bedingung zur Erreichbarkeit der Bytes erfüllt ist. Es beginnt keine Lebensdauer und korrigiert keine Ausrichtung. Hier ist es nicht nötig.
Der explizite Destruktoraufruf p->~T() zerstört das Objekt, ohne den Speicher der Arena oder des Puffers freizugeben. Zerstöre hier jedes erfolgreich konstruierte Objekt genau einmal, bevor du den Platz erneut verwendest oder der Puffer seine Lebensdauer beendet. Verwende für ein Objekt in diesem Puffer kein delete p: Ein zu einem passenden allokierenden New-Ausdruck gehörender Delete-Ausdruck zerstört normalerweise das Objekt und gibt den Speicher frei.
= delete definiert eine gelöschte Funktion; es ist kein Delete-Ausdruck. Die Funktion nimmt an der Überladungsauflösung teil, aber ein Aufruf, der sie auswählt, ist nicht wohlgeformt. Slot löscht Kopier- und Verschiebekonstruktor sowie beide zugehörigen Zuweisungsoperatoren. Beim standardmäßigen elementweisen Kopieren würde der Zeiger auf den Quellpuffer kopiert, ohne ein Item im Zielpuffer zu konstruieren.
Beispiele
#include <cstddef>
#include <cstdio>
#include <new>
struct Item {
int value;
explicit Item(int n) : value(n) {}
~Item() { std::puts("destroyed"); }
};
class Slot {
alignas(Item) std::byte storage_[sizeof(Item)];
Item* item_ = nullptr;
public:
Slot() = default;
~Slot() { reset(); }
Slot(const Slot&) = delete;
Slot& operator=(const Slot&) = delete;
Slot(Slot&&) = delete;
Slot& operator=(Slot&&) = delete;
Item& emplace(int n) {
reset();
item_ = ::new (static_cast<void*>(storage_)) Item(n);
return *item_;
}
void reset() noexcept {
if (item_) {
item_->~Item();
item_ = nullptr;
}
}
};
int main() {
Slot slot;
std::printf("%d\n", slot.emplace(7).value);
std::printf("%d\n", slot.emplace(9).value);
}Ergebnis
7 destroyed 9 destroyed
Der zweite `emplace`-Aufruf zerstört das `Item` mit dem Wert `7`, bevor er im selben Puffer das Objekt mit `9` konstruiert. Der Destruktor von `Slot` zerstört das zweite Objekt.
Zugehörige Lektionen
- C++ · Lektion 16 · Fortgeschritten · Version: 3
- C++ · Lektion 19 · Fortgeschritten · Version: 3
Quellen
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23 baseline)
- New expressions [expr.new] — C++ working draft
- Non-allocating forms [new.delete.placement] — C++ working draft
- Lifetime [basic.life] — C++ working draft
- Value category and type accessibility [basic.lval] — C++ working draft
- Pointer optimization barrier [ptr.launder] — C++ working draft
- Destructors [class.dtor] — C++ working draft
- Delete expressions [expr.delete] — C++ working draft
- Deleted definitions [dcl.fct.def.delete] — C++ working draft