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

CKTIS / C++

Memoria: propiedad, copias y vida de los objetos

Distingue el almacenamiento del objeto que lo ocupa y de la responsabilidad sobre el recurso. Aprende qué son la duración de almacenamiento automática y dinámica, la copia, placement new, la destrucción explícita y el aliasing estricto.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

T copy = original; T* alias = &original; T* p = ::new (static_cast<void*>(storage)) T{args}; p->~T();

El almacenamiento da espacio a los datos; la vida corresponde al objeto que lo ocupa. Suele empezar al disponer de espacio suficiente y bien alineado y terminar la inicialización. Para un objeto de clase acaba al iniciarse la llamada al destructor; liberar o reutilizar el espacio también puede acabarla. Una dirección válida no basta para acceder al objeto.

Duración de almacenamiento. Determina la disponibilidad del espacio. Una variable local ordinaria tiene duración automática, hasta salir del bloque. Los objetos creados con new que asigna memoria tienen duración dinámica y pueden sobrevivir al bloque. Un std::unique_ptr local puede tener duración automática y su objeto, dinámica. «Pila» y «montículo» son modelos habituales de implementación, no definiciones.

Propiedad. Implica liberar el recurso. Usa RAII: el destructor del propietario se encarga. std::unique_ptr se puede mover, no copiar. Copiar un puntero sin gestionar copia la dirección, no el objeto ni el deber de eliminarlo. Por defecto, una clase copia sus miembros; un miembro puntero conserva su destino. La copia no tiene por qué ser profunda; dos propietarios independientes de una dirección se arriesgan a eliminar dos veces el objeto.

Placement new. En ::new (storage) T{args}, el :: inicial limita al ámbito global la búsqueda de la función de asignación de memoria, pero no obliga a elegir la sobrecarga estándar que recibe un void*. Una sobrecarga global que encaje mejor con el tipo de storage puede asignar memoria. El ejemplo usa la forma ::new (static_cast<void*>(storage)) T{args} con el tipo Item: se selecciona la sobrecarga estándar que no asigna memoria y se construye el objeto en el espacio suministrado. La conversión a void* por sí sola no garantiza esa elección para cualquier T. Si T requiere una alineación superior a la predeterminada de new (alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__), la primera fase de la resolución de sobrecargas incluye un argumento de tipo std::align_val_t antes del argumento de placement. En ese caso puede seleccionarse una sobrecarga global viable operator new(std::size_t, std::align_val_t, void*) en lugar de la sobrecarga estándar que no asigna memoria. El espacio debe ser suficiente y estar bien alineado. p->~T() destruye explícitamente el objeto sin liberar el espacio. No uses delete para un objeto situado en un búfer local. No destruyas un objeto dos veces: tras destruir explícitamente una variable local ordinaria con destructor no trivial, reconstruye correctamente un objeto del tipo original antes de la destrucción automática.

Aliasing estricto. Limita los tipos con los que se puede leer o modificar el valor de un objeto. reinterpret_cast no permite acceder mediante un tipo incompatible. char, unsigned char y std::byte permiten acceder a la representación, pero no sustituyen las reglas de vida. El ejemplo usa un subconjunto compatible con C++23; la URL del estándar lleva al borrador en evolución, no a la edición fija de C++23.

Identificadores de referencia incluidos en esta entrada: Object lifetime, placement new, explicit destruction and strict aliasing, Automatic and dynamic storage duration.

Ejemplos

#include <cstddef>
#include <iostream>
#include <memory>
#include <new>

struct Item {
    int value;
    ~Item() {}
};

int main() {
    Item original{7};
    Item copy = original;
    Item* alias = &original;
    alias->value = 9;

    auto owner = std::make_unique<Item>();
    owner->value = 11;

    alignas(Item) std::byte storage[sizeof(Item)];
    Item* placed = ::new (static_cast<void*>(storage)) Item{13};

    std::cout << original.value << ' ' << copy.value << ' '
              << owner->value << ' ' << placed->value << '\n';

    placed->~Item();
}

Resultado

9 7 11 13

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes