CKTIS / C++
Selección de sobrecargas para la asignación alineada
Aprende cómo C++23 selecciona las sobrecargas de clase de `operator new` y `operator delete` y por qué las dos llamadas globales deben recibir el mismo valor de alineación.
Versión: ISO C++23; implementation support may vary
Sintaxis
// Class members for single-object allocation and deallocation:
static void* operator new(std::size_t bytes, std::align_val_t alignment);
static void operator delete(void* p, std::align_val_t alignment) noexcept;
// Expressions that manage the lifetime of a T object:
T* p = new T{};
delete p;
// Direct calls that manage raw storage:
void* raw = ::operator new(bytes, alignment);
::operator delete(raw, alignment);new T{} obtiene memoria e inicializa en ella un objeto de tipo T. En el caso mostrado, delete p destruye el objeto y después libera su memoria. Las llamadas directas a operator new y operator delete gestionan memoria sin inicializar objetos: no llaman al constructor ni al destructor de T.
En C++23, new T{} busca operator new primero en la clase. Las declaraciones que encuentra allí ocultan las sobrecargas globales; ::new T{} omite el ámbito de la clase. Si alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, el primer intento de resolución pasa alignof(T) como std::align_val_t después del tamaño. Si no hay una función que encaje, se vuelve a intentar sin la alineación. Para los demás tipos se invierte el orden. Una sobrecarga de clase sin parámetro de alineación debe devolver igualmente memoria bien alineada.
Para el tipo mostrado, delete p busca operator delete en la clase y pasa al ámbito global si no encuentra ninguna declaración allí. La función de liberación se elige independientemente de la de asignación: por encima del mismo umbral se prefiere la forma con std::align_val_t; en los demás casos, la forma sin ese parámetro. Si el constructor lanza una excepción tras una asignación exitosa, la expresión new llama a una función de liberación adecuada si la encuentra y luego la excepción sigue propagándose.
Pasa el puntero devuelto por ::operator new(bytes, alignment) a ::operator delete(p, alignment) con exactamente el mismo valor de alineación. Usar la sobrecarga sin alineación o con otro valor produce comportamiento indefinido. ::delete p sigue siendo una expresión que destruye el objeto, pero omite la liberación específica de la clase, por lo que aquí no sustituye a delete p.
El ejemplo trata un solo objeto; para los arrays se emparejan new[] y delete[]. outstanding cuenta las asignaciones exitosas a través de esta clase que aún no se han liberado, no los bytes ni los objetos vivos. Volver a cero no demuestra que la gestión de memoria sea segura.
Ejemplos
#include <cstddef>
#include <iostream>
#include <new>
struct alignas(64) Block {
inline static std::size_t outstanding = 0;
int value{};
static void* operator new(std::size_t bytes, std::align_val_t alignment) {
void* p = ::operator new(bytes, alignment);
++outstanding;
return p;
}
static void operator delete(void* p, std::align_val_t alignment) noexcept {
if (p == nullptr) return;
::operator delete(p, alignment);
--outstanding;
}
};
static_assert(alignof(Block) > __STDCPP_DEFAULT_NEW_ALIGNMENT__);
int main() {
std::cout << Block::outstanding << '\n';
Block* p = new Block{};
std::cout << Block::outstanding << '\n';
delete p;
std::cout << Block::outstanding << '\n';
}Resultado
0 1 0
Si la asignación tiene éxito, se esperan las líneas `0`, `1`, `0`. La plataforma de destino debe admitir `alignas(64)` y cumplir la condición de `static_assert`; la compatibilidad depende de la implementación.
Lecciones relacionadas
- C++ · Lección 20 · Avanzado · Versión: 3