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

CKTIS / C++

operator new y operator delete de clase: selección de sobrecargas alineadas

Distingue la gestión del almacenamiento de la vida del objeto y pasa el mismo valor de alineación a las funciones globales correspondientes.

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

Sintaxis

#include <cstddef>
#include <new>

struct T {
    static void* operator new(std::size_t bytes);
    static void operator delete(void* ptr) noexcept;

    static void* operator new(std::size_t bytes, std::align_val_t alignment);
    static void operator delete(void* ptr, std::align_val_t alignment) noexcept;
};

new T(...) obtiene almacenamiento y después inicializa un objeto en él. Para un puntero válido no nulo, delete p, con la forma no destructora de operator delete que se muestra aquí, destruye el objeto antes de liberar el almacenamiento. Una llamada directa a operator new no ejecuta automáticamente el constructor, y una llamada directa a un operator delete no destructor no ejecuta automáticamente el destructor. En cambio, un operator delete destructor puede llamar al destructor desde el cuerpo de la función, incluso si se invoca directamente.

Las funciones de asignación y liberación propias de una clase son miembros estáticos aunque se omita static. Para un solo objeto, la búsqueda del nombre normalmente empieza en la clase; las declaraciones que se encuentran allí ocultan las funciones globales del mismo nombre. Las expresiones ::new y ::delete omiten la búsqueda en la clase, pero siguen inicializando o destruyendo el objeto. No omitas una parte de la pareja si la otra depende de un mecanismo de asignación personalizado. Los arrays usan las formas separadas new[] y delete[].

Las sobrecargas con std::align_val_t de <new> existen desde C++17. En C++23, si alignof(T) supera __STDCPP_DEFAULT_NEW_ALIGNMENT__, new prueba primero con un argumento de alineación y, si no encuentra una coincidencia, vuelve a intentarlo sin él entre las mismas declaraciones. En el umbral o por debajo de él, el orden se invierte. Al seleccionar una función de liberación ordinaria, se prefiere una sobrecarga con o sin parámetro de alineación según ese mismo umbral.

Si el miembro llama a ::operator new(bytes, alignment), libera ese bloque con ::operator delete(ptr, alignment) usando el mismo valor de alineación. La variante sin alineación no sirve como sustituto: incumplir este requisito causa comportamiento indefinido. En el ejemplo, si la asignación falla, se lanza std::bad_alloc antes de incrementar el contador. Si el constructor lanza una excepción después de asignar el bloque, la expresión new llama a una función de liberación adecuada si encuentra una y después propaga la excepción.

outstanding cuenta los bloques asignados por esta pareja que aún no se han liberado. No cuenta bytes ni objetos vivos, no demuestra que el uso de la memoria sea seguro y no admite actualizaciones concurrentes seguras.

Ejemplos

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

struct alignas(64) Tracked final {
    enum class Error { construction_failed };
    static inline std::size_t outstanding = 0;

    explicit Tracked(bool fail) {
        if (fail) {
            throw Error::construction_failed;
        }
    }

    static void* operator new(std::size_t bytes, std::align_val_t alignment) {
        void* ptr = ::operator new(bytes, alignment);
        ++outstanding;
        return ptr;
    }

    static void operator delete(void* ptr, std::align_val_t alignment) noexcept {
        if (ptr != nullptr) {
            ::operator delete(ptr, alignment);
            --outstanding;
        }
    }
};

static_assert(alignof(Tracked) > __STDCPP_DEFAULT_NEW_ALIGNMENT__);

int main() {
    auto* ptr = new Tracked(false);
    std::printf("After new: %zu\n", Tracked::outstanding);
    delete ptr;
    std::printf("After delete: %zu\n", Tracked::outstanding);

    try {
        auto* unexpected = new Tracked(true);
        delete unexpected;
        return 1;
    } catch (Tracked::Error) {
        std::printf("After constructor throws: %zu\n", Tracked::outstanding);
    }
}

Resultado

After new: 1
After delete: 0
After constructor throws: 0

El ejemplo requiere compatibilidad con `alignas(64)` y que la aserción estática confirme que se supera el umbral predeterminado. Si ambas asignaciones tienen éxito, `1` indica un bloque pendiente de liberar; los dos valores `0` muestran la liberación por `delete` y tras una excepción del constructor, respectivamente.

Lecciones relacionadas

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

Fuentes