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

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

Fontes