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.