CKTIS / C++
Placement new: constructie in bestaande opslag
Construeer een object op een voorbereide geheugenplek, beheer de levensduur los van de opslag en maak de eigenaar niet-kopieerbaar en niet-verplaatsbaar.
Versie: 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 construeert ::new (static_cast<void*>(storage)) T(args...) een T op het opgegeven adres en geeft het een T* terug als de niet-allocerende standaardoverload operator new(std::size_t, void*) uit <new> wordt geselecteerd. Die globale overload geeft alleen het adres terug. Het voorvoegsel :: slaat zoeken in de klasse over, maar de cast naar void* garandeert niet dat de standaardoverload wordt geselecteerd. Als alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, neemt de overloadresolutie eerst een extra argument van het type std::align_val_t mee. Daardoor kan in plaats daarvan een geschikte globale placement-overload met een uitlijningsargument worden geselecteerd. Als er geen passende allocatiefunctie wordt gevonden, wordt de overloadresolutie zonder het uitlijningsargument herhaald. Gewone allocerende new T(args...) verkrijgt opslag en initialiseert het object. Andere placement-overloads kunnen wel opslag alloceren.
Geef een geldig adres dat niet nul is, met minstens sizeof(T) beschikbare bytes en een uitlijning die aan alignof(T) voldoet. Het voorbeeld gebruikt alignas(Item) voor de uitlijning. De levensduur van het geconstrueerde object begint na succesvolle initialisatie. Als de constructor een uitzondering gooit, geeft de bijbehorende standaard-placementfunctie operator delete(void*, void*) niets vrij. Markeer de plek pas als bezet nadat de constructie is geslaagd.
Bewaar de T* die de new-expressie teruggeeft. Een cast alleen construeert geen object, en hetzelfde adres staat geen toegang toe via een incompatibel type (strict aliasing). std::launder kan een pointer opleveren naar een al levend object van een soortgelijk type op dat adres, mits aan de bereikbaarheidseis voor de bytes is voldaan. Het start geen levensduur en corrigeert geen uitlijning. Hier is het niet nodig.
De expliciete destructoraanroep p->~T() vernietigt het object zonder de opslag van de arena of buffer vrij te geven. Vernietig in dit patroon elk succesvol geconstrueerd object precies één keer voordat je de plek hergebruikt of de buffer ophoudt te bestaan. Gebruik geen delete p voor een object in deze buffer: een delete-expressie die bij een passende allocerende new-expressie hoort, vernietigt normaal het object en geeft de opslag vrij.
= delete definieert een verwijderde functie; het is geen delete-expressie. De functie doet nog steeds mee aan overloadresolutie, maar een aanroep die haar selecteert is ongeldig. Slot verwijdert de kopieer- en verplaatsingsconstructor en beide bijbehorende toewijzingsoperatoren. Standaard lid voor lid kopiëren zou de pointer naar de bronbuffer kopiëren zonder een Item in de doelbuffer te construeren.
Voorbeelden
#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);
}Resultaat
7 destroyed 9 destroyed
De tweede aanroep van `emplace` vernietigt het `Item` met `7` voordat het object met `9` in dezelfde buffer wordt geconstrueerd. De destructor van `Slot` vernietigt het tweede object.
Gerelateerde lessen
- C++ · Les 16 · Gevorderd · Versie: 3
- C++ · Les 19 · Gevorderd · Versie: 3
Bronnen
- 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