CKTIS / C++
Placement new : construire dans une zone mémoire existante
Construisez un objet dans un emplacement préparé, gérez sa durée de vie séparément de la mémoire et interdisez la copie et le déplacement du propriétaire.
Version : ISO C++23; implementation support may vary
Syntaxe
#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;En C++23, l’expression ::new (static_cast<void*>(storage)) T(args...) construit un T à l’adresse fournie et renvoie un T* si elle sélectionne la surcharge standard non allouante operator new(std::size_t, void*) de <new>. Cette surcharge globale renvoie simplement l’adresse. Le préfixe :: écarte la recherche dans la classe, mais la conversion en void* ne garantit pas la sélection de la surcharge standard. Si alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, la résolution de surcharge inclut d’abord un argument supplémentaire de type std::align_val_t : une surcharge globale de placement qui accepte l’argument d’alignement peut donc être sélectionnée à la place. Si aucune fonction d’allocation correspondante n’est trouvée, la résolution reprend sans l’argument d’alignement. L’expression allouante ordinaire new T(args...) obtient de la mémoire et initialise l’objet. D’autres surcharges de placement peuvent allouer de la mémoire.
Fournissez une adresse valide et non nulle, au moins sizeof(T) octets disponibles et un alignement conforme à alignof(T). L’exemple utilise alignas(Item) pour l’alignement. La durée de vie de l’objet construit commence après la réussite de l’initialisation. Si le constructeur lève une exception, l’operator delete(void*, void*) de placement standard correspondant ne libère rien. Ne marquez l’emplacement comme occupé qu’après la réussite de la construction.
Conservez le T* renvoyé par l’expression new. Une conversion de type seule ne construit pas d’objet, et une adresse identique n’autorise pas l’accès via un type incompatible (règles d’aliasing strict). std::launder peut fournir un pointeur vers un objet de type similaire déjà vivant à cette adresse si la condition d’accessibilité des octets est remplie. Cette fonction ne démarre pas de durée de vie et ne corrige pas l’alignement. Elle n’est pas nécessaire ici.
L’appel explicite au destructeur p->~T() détruit l’objet sans libérer la mémoire de l’arène ou du tampon. Dans ce modèle, détruisez chaque objet construit avec succès exactement une fois, avant de réutiliser l’emplacement ou de laisser le tampon arriver en fin de vie. N’utilisez pas delete p sur un objet de ce tampon : une expression delete associée à une expression new allouante appropriée détruit normalement l’objet et libère la mémoire.
= delete définit une fonction supprimée ; ce n’est pas une expression delete. La fonction participe toujours à la résolution de surcharge, mais un appel qui la sélectionne est mal formé. Slot supprime les constructeurs de copie et de déplacement ainsi que les deux opérateurs d’affectation correspondants. La copie membre par membre par défaut copierait le pointeur vers le tampon source sans construire d’Item dans le tampon de destination.
Exemples
#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);
}Résultat
7 destroyed 9 destroyed
Le second appel à `emplace` détruit l’`Item` contenant `7` avant de construire celui qui contient `9` dans le même tampon. Le destructeur de `Slot` détruit le second objet.
Leçons associées
- C++ · Leçon 16 · Avancé · Version : 3
- C++ · Leçon 19 · Avancé · Version : 3
Sources
- 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