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

CKTIS / C++

Operadores de asignación y liberación de memoria específicos de una clase

Una clase puede definir sus propias funciones operator new y operator delete para controlar la asignación y liberación de almacenamiento. Las sobrecargas que reciben std::align_val_t gestionan la alineación y deben ser compatibles con la función de liberación correspondiente.

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

Sintaxis

static void* operator new(std::size_t n);
static void operator delete(void* p) noexcept;
static void* operator new(std::size_t n, std::align_val_t a);
static void operator delete(void* p, std::align_val_t a) noexcept;

Las funciones operator new y operator delete específicas de una clase gestionan el almacenamiento; no sustituyen a los constructores ni a los destructores. Son estáticas incluso sin static y no pueden ser virtuales. Un new T ordinario busca primero la función de asignación en la clase; las declaraciones encontradas allí pueden ocultar las sobrecargas globales. ::new T fuerza la búsqueda global, mientras que ::delete p omite las funciones de liberación específicas de la clase. No las omitas si eso rompe la compatibilidad entre asignación y liberación.

Para alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, el primer intento de seleccionar operator new incluye un argumento std::align_val_t. Si no hay una función que encaje, se vuelve a intentar la selección sin ese argumento; para los demás tipos, el orden se invierte. Por tanto, la mera existencia de un operator new(std::size_t) específico de la clase no garantiza una alineación mayor: su implementación debe proporcionar almacenamiento adecuado para el objeto que se crea.

Asegura rutas de liberación compatibles: el almacenamiento obtenido mediante el ::operator new(n, a) global debe liberarse mediante el ::operator delete(p, a) global con la misma alineación. En un delete ordinario, la preferencia por una sobrecarga que recibe std::align_val_t depende de la alineación del tipo. Dentro de la clase, una vez aplicada esa preferencia, gana la sobrecarga sin std::size_t frente a la que recibe un tamaño. La desasignación no debería lanzar excepciones.

operator new[] y operator delete[] forman un par distinto: las sobrecargas para objetos individuales no interceptan arrays. Si falla la inicialización, la expresión new puede invocar una función de liberación adecuada. El ejemplo solo contempla un objeto individual; ambas rutas de asignación delegan en la sobrecarga global alineada y ambas rutas de liberación en su equivalente.

Identificadores de referencia incluidos en esta entrada: Class-specific operator new/delete and matching aligned overloads.

Ejemplos

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

// This declaration requires implementation support for 64-byte alignment.
// C++23 does not guarantee that support.
struct alignas(64) Node final {
    int value = 42;
    inline static int allocations = 0;
    inline static int deallocations = 0;

    static void* operator new(std::size_t n) {
        return Node::operator new(n, std::align_val_t{alignof(Node)});
    }

    static void* operator new(std::size_t n, std::align_val_t a) {
        void* p = ::operator new(n, a);
        ++allocations;
        return p;
    }

    static void operator delete(void* p) noexcept {
        Node::operator delete(p, std::align_val_t{alignof(Node)});
    }

    static void operator delete(void* p, std::align_val_t a) noexcept {
        ++deallocations;
        ::operator delete(p, a);
    }
};

int main() {
    Node* p = new Node;
    const int value = p->value;
    delete p;
    std::cout << value << ' ' << Node::allocations << ' '
              << Node::deallocations << '\n';
}

Resultado

42 1 1

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