CKTIS / C++
Seleção de sobrecargas na alocação alinhada
Aprende como o C++23 seleciona as sobrecargas de classe de `operator new` e `operator delete` e por que razão as duas chamadas globais têm de receber o mesmo valor de alinhamento.
Versão: ISO C++23; implementation support may vary
Sintaxe
// 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{} obtém memória e inicializa nela um objeto de tipo T. No caso apresentado, delete p destrói o objeto e depois liberta a memória. As chamadas diretas a operator new e a operator delete gerem memória bruta: não invocam o construtor nem o destrutor de T.
Em C++23, new T{} procura operator new primeiro na classe. As declarações encontradas aí ocultam as sobrecargas globais; ::new T{} ignora o âmbito da classe. Se alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, a primeira tentativa de resolução passa alignof(T) como std::align_val_t depois do tamanho. Se não houver uma função compatível, a segunda tentativa omite o alinhamento. Para os outros tipos, a ordem é inversa. Uma sobrecarga de classe sem parâmetro de alinhamento continua a ter de devolver memória devidamente alinhada.
Para o tipo apresentado, delete p procura operator delete na classe e só procura no âmbito global se não encontrar aí nenhuma declaração. A função de desalocação é selecionada independentemente da função de alocação: acima do mesmo limiar, prefere-se uma forma com std::align_val_t; nos restantes casos, uma sem esse parâmetro. Se o construtor lançar uma exceção após uma alocação bem-sucedida, a expressão new chama uma função de desalocação adequada, se a encontrar, e a exceção continua a propagar-se.
Passa o ponteiro devolvido por ::operator new(bytes, alignment) a ::operator delete(p, alignment) com exatamente o mesmo valor de alinhamento. Usar a sobrecarga sem alinhamento ou um valor diferente resulta em comportamento indefinido. ::delete p continua a ser uma expressão que destrói o objeto, mas contorna a desalocação específica da classe e, por isso, não substitui delete p neste exemplo.
O exemplo trata de um único objeto; para arrays, usa-se new[] com delete[]. outstanding conta as alocações bem-sucedidas através desta classe que ainda não foram libertadas, não os bytes nem os objetos vivos. O regresso a zero não demonstra que a gestão da memória seja segura.
Exemplos
#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
Se a alocação for bem-sucedida, esperam-se as linhas `0`, `1`, `0`. A plataforma de destino tem de suportar `alignas(64)` e satisfazer a condição de `static_assert`; o suporte depende da implementação.
Lições relacionadas
- C++ · Lição 20 · Avançado · Versão: 3