Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes