Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

Tiempo de vida de los objetos y aliasing estricto

La memoria puede seguir disponible tras destruir un objeto. El tiempo de vida indica cuándo existe el objeto, y el aliasing estricto indica mediante qué tipos se puede acceder a su valor.

Versión: ISO C++23; implementation support may vary

Sintaxis

alignas(T) std::byte storage[sizeof(T)];
T* p = ::new (static_cast<void*>(storage)) T{args...};
p->~T();

// Schematic: T is a class type; args... denotes its initializer arguments.
// Headers: <cstddef> for std::byte; <new> for placement new and std::launder.
// When its preconditions are met: T* q = std::launder(candidate);

En ISO C++23 conviene distinguir el almacenamiento, el tiempo de vida del objeto y el tipo de la expresión de acceso. Normalmente, el tiempo de vida comienza cuando hay almacenamiento con tamaño y alineación adecuados y termina la inicialización. Para un objeto de clase, acaba cuando comienza la llamada al destructor; también puede acabar si se libera su almacenamiento o lo reutiliza un objeto no anidado en él. Durante la construcción y la destrucción se aplican reglas especiales.

::new (static_cast<void*>(storage)) T{args...} selecciona la forma global estándar de placement new que no reserva memoria. La función operator new devuelve la dirección recibida; la expresión new construye allí un T y devuelve un T*. p->~T() llama al destructor sin liberar la memoria de la arena o del búfer. No uses delete p con un objeto construido en un búfer de este tipo ni lo destruyas dos veces.

Tras la destrucción, el almacenamiento puede seguir disponible, pero no se debe leer ni escribir el valor del objeto fuera de su tiempo de vida. Al construir un reemplazo, usa el puntero que devuelve la expresión new. Si el reemplazo es transparente, los punteros, las referencias y el nombre anteriores pasan a designar el objeto nuevo una vez que está vivo. Por ejemplo, esto ocurre al sustituir un objeto completo no const por otro objeto completo del mismo tipo en exactamente el mismo espacio.

std::launder(p) puede obtener un puntero al reemplazo si las referencias anteriores no pasan a designarlo automáticamente. Ya debe existir en esa dirección un objeto vivo de tipo similar en el sentido del estándar, y todos los bytes alcanzables mediante el resultado deben ser alcanzables mediante p. std::launder no inicia el tiempo de vida, no corrige la alineación ni elude las reglas de aliasing.

El aliasing estricto se refiere al tipo de la glvalue, la expresión que designa el objeto. Acceder al valor almacenado a través de un tipo no permitido causa comportamiento indefinido. Se permiten un tipo similar al tipo dinámico del objeto, su tipo correspondiente con o sin signo, y char, unsigned char o std::byte para acceder a su representación. signed char no es una excepción general para el acceso por bytes. Un reinterpret_cast por sí solo no legitima el acceso ni crea un objeto.

Ejemplos

#include <cstddef>
#include <cstdio>
#include <new>

struct Item {
    int value;
    ~Item() { std::puts("destroy"); }
};

int main() {
    alignas(Item) std::byte storage[sizeof(Item)];
    void* slot = storage;

    Item* p = ::new (slot) Item{7};
    const unsigned int& alias = reinterpret_cast<const unsigned int&>(p->value);
    std::printf("%u\n", alias);
    p->~Item();

    Item* q = ::new (slot) Item{9};
    std::printf("%d\n", q->value);
    q->~Item();
}

Resultado

7
destroy
9
destroy

El programa lee el miembro `int` vivo mediante una referencia al tipo correspondiente `unsigned int`. Tras destruir el primer `Item`, construye otro en el mismo búfer y usa el puntero nuevo. Cada destructor imprime `destroy`; ninguno libera el búfer.

Lecciones relacionadas

  • C++ · Lección 16 · Avanzado · Versión: 3

Fuentes