CKTIS / C++
operator new e operator delete de classe: seleção de sobrecargas com alinhamento
Distingue a gestão do armazenamento do tempo de vida do objeto e passa o mesmo valor de alinhamento às funções globais correspondentes.
Versão: ISO C++23; implementation support may vary
Sintaxe
#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(...) obtém armazenamento e, em seguida, inicializa nele um objeto. Para um ponteiro válido não nulo, delete p, com a forma não destrutiva de operator delete aqui apresentada, destrói o objeto antes de libertar o armazenamento. Uma chamada direta a operator new não executa automaticamente o construtor, e uma chamada direta a um operator delete não destrutivo não executa automaticamente o destrutor. Já um operator delete destrutivo pode chamar o destrutor no corpo da função, mesmo quando é chamado diretamente.
As funções de alocação e libertação específicas de uma classe são membros estáticos, mesmo sem static. Para um objeto único, a pesquisa do nome começa normalmente na classe; as declarações encontradas aí ocultam as funções globais com o mesmo nome. As expressões ::new e ::delete ignoram a pesquisa na classe, mas continuam a inicializar ou a destruir o objeto. Não contornes um dos lados do par se o outro depender de um mecanismo de alocação personalizado. Os arrays usam as formas distintas new[] e delete[].
As sobrecargas com std::align_val_t de <new> estão disponíveis desde C++17. Em C++23, se alignof(T) exceder __STDCPP_DEFAULT_NEW_ALIGNMENT__, new tenta primeiro resolver a sobrecarga com um argumento de alinhamento e, se não encontrar correspondência, tenta novamente sem ele entre as mesmas declarações. No limiar ou abaixo dele, a ordem é inversa. Na escolha de uma função de libertação normal, o mesmo limiar determina a preferência por uma sobrecarga com ou sem parâmetro de alinhamento.
Se o membro chamar ::operator new(bytes, alignment), liberta esse bloco com ::operator delete(ptr, alignment), usando o mesmo valor de alinhamento. A variante sem alinhamento não é um substituto: violar este requisito provoca comportamento indefinido. No exemplo, uma falha de alocação lança std::bad_alloc antes de incrementar o contador. Se o construtor lançar uma exceção após a alocação, a expressão new chama uma função de libertação adequada, se a encontrar, e propaga a exceção.
outstanding conta os blocos alocados através deste par que ainda não foram libertados. Não conta bytes nem objetos vivos, não demonstra segurança da memória e não é seguro para atualizações concorrentes.
Exemplos
#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
O exemplo requer suporte para `alignas(64)` e que a asserção estática confirme que o limiar predefinido foi excedido. Se ambas as alocações forem bem-sucedidas, `1` indica um bloco por libertar; os dois valores `0` mostram a libertação por `delete` e após uma exceção do construtor, respetivamente.
Lições relacionadas
- C++ · Lição 20 · Avançado · Versão: 3