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

CKTIS / C++

Operadores de alocação e libertação específicos da classe

Uma classe pode definir as suas próprias funções operator new e operator delete para controlar a alocação e a libertação de memória. As sobrecargas que recebem std::align_val_t tratam do alinhamento e têm de ser compatíveis com a função de libertação adequada.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

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;

As funções operator new e operator delete específicas da classe gerem a memória; não substituem construtores nem destrutores. São estáticas mesmo sem static e não podem ser virtuais. Um new T normal procura primeiro a função de alocação na classe; as declarações aí encontradas podem ocultar as sobrecargas globais. ::new T força a pesquisa global, enquanto ::delete p contorna as funções de libertação específicas da classe. Não as contorne se isso quebrar a compatibilidade entre alocação e libertação.

Para alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, a primeira tentativa de selecionar operator new inclui um argumento std::align_val_t. Se não existir uma função correspondente, a seleção é tentada de novo sem esse argumento; para os outros tipos, a ordem é inversa. A mera existência de um operator new(std::size_t) específico da classe não garante, por isso, um alinhamento superior: a implementação tem de fornecer memória adequada ao objeto criado.

Garanta percursos de libertação compatíveis: a memória obtida através do ::operator new(n, a) global deve ser libertada através do ::operator delete(p, a) global com o mesmo alinhamento. Num delete normal, a preferência por uma sobrecarga que recebe std::align_val_t depende do alinhamento do tipo. No âmbito da classe, depois de aplicada essa preferência, a sobrecarga sem std::size_t prevalece sobre a que recebe um tamanho. A desalocação não deve lançar exceções.

operator new[] e operator delete[] formam um par separado: as sobrecargas para objetos individuais não intercetam arrays. Se a inicialização falhar, a expressão new pode chamar uma função de libertação adequada. O exemplo abrange apenas um objeto individual; ambos os percursos de alocação delegam na sobrecarga global alinhada e ambos os percursos de libertação na respetiva contraparte.

Identificadores de referência abrangidos por esta entrada: Class-specific operator new/delete and matching aligned overloads.

Exemplos

#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

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes