CKTIS / C++
Placement new: construcción en almacenamiento existente
Construye un objeto en un espacio preparado, gestiona su tiempo de vida por separado del almacenamiento e impide copiar y mover el objeto propietario.
Versión: ISO C++23; implementation support may vary
Sintaxis
#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, ::new (static_cast<void*>(storage)) T(args...) construye un T en la dirección indicada y devuelve un T* si se selecciona la sobrecarga estándar operator new(std::size_t, void*) de <new>, que no asigna memoria. Esa sobrecarga global solo devuelve la dirección. El prefijo :: evita la búsqueda en el ámbito de la clase, pero la conversión a void* no garantiza que se seleccione la sobrecarga estándar. Si alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, la resolución de sobrecargas incluye primero un argumento adicional de tipo std::align_val_t, por lo que puede seleccionarse en su lugar una sobrecarga global de placement que acepte el argumento de alineación. Si no se encuentra una función de asignación de memoria que coincida, se repite la resolución sin el argumento de alineación. La expresión ordinaria new T(args...) que asigna memoria obtiene almacenamiento e inicializa el objeto. Otras sobrecargas de placement pueden asignar memoria.
Proporciona una dirección válida y no nula, al menos sizeof(T) bytes disponibles y una alineación que cumpla alignof(T). El ejemplo usa alignas(Item) para la alineación. El tiempo de vida del objeto construido comienza tras inicializarlo correctamente. Si el constructor lanza una excepción, el operator delete(void*, void*) de placement estándar correspondiente no libera nada. Marca el espacio como ocupado solo cuando la construcción tenga éxito.
Conserva el T* que devuelve la expresión new. Una conversión de tipo por sí sola no construye un objeto, y que la dirección coincida no permite acceder mediante un tipo incompatible (reglas de aliasing estricto). std::launder puede obtener un puntero a un objeto de tipo similar que ya esté vivo en esa dirección si se cumple el requisito de alcanzabilidad de los bytes. No inicia el tiempo de vida ni corrige la alineación. Aquí no hace falta.
La llamada explícita al destructor p->~T() destruye el objeto sin liberar la memoria de la arena ni del búfer. En este patrón, destruye cada objeto construido correctamente una sola vez, antes de reutilizar el espacio o de que termine el tiempo de vida del búfer. No uses delete p con un objeto de este búfer: una expresión delete emparejada con una expresión new que asignó la memoria de forma adecuada normalmente destruye el objeto y libera el almacenamiento.
= delete define una función eliminada; no es una expresión delete. La función sigue participando en la resolución de sobrecargas, pero una llamada que la selecciona está mal formada. Slot elimina los constructores de copia y movimiento y los dos operadores de asignación correspondientes. La copia predeterminada miembro a miembro copiaría el puntero al búfer de origen sin construir un Item en el búfer de destino.
Ejemplos
#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);
}Resultado
7 destroyed 9 destroyed
La segunda llamada a `emplace` destruye el `Item` que contiene `7` antes de construir el que contiene `9` en el mismo búfer. El destructor de `Slot` destruye el segundo objeto.
Lecciones relacionadas
- C++ · Lección 16 · Avanzado · Versión: 3
- C++ · Lección 19 · Avanzado · Versión: 3
Fuentes
- 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