Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Selezione degli overload per l’allocazione allineata

Scopri come C++23 seleziona gli overload di classe di `operator new` e `operator delete` e perché le due chiamate globali devono ricevere lo stesso valore di allineamento.

Versione: ISO C++23; implementation support may vary

Sintassi

// 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{} ottiene memoria e vi inizializza un oggetto di tipo T. Nel caso mostrato, delete p distrugge l’oggetto e poi ne libera la memoria. Le chiamate dirette a operator new e operator delete gestiscono memoria grezza: non chiamano né il costruttore né il distruttore di T.

In C++23, new T{} cerca operator new prima nella classe. Le dichiarazioni trovate nella classe nascondono gli overload globali; ::new T{} salta l’ambito della classe. Se alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, il primo tentativo di risoluzione passa alignof(T) come std::align_val_t dopo la dimensione. Se nessuna funzione corrisponde, si ritenta senza l’allineamento. Per gli altri tipi l’ordine è inverso. Anche un overload di classe senza parametro di allineamento deve restituire memoria allineata correttamente.

Per il tipo mostrato, delete p cerca operator delete nella classe e passa all’ambito globale se non vi trova dichiarazioni. La funzione di deallocazione viene scelta indipendentemente da quella di allocazione: sopra la stessa soglia si preferisce una forma con std::align_val_t, altrimenti una senza. Se il costruttore lancia un’eccezione dopo che l’allocazione è riuscita, l’espressione new chiama una funzione di deallocazione adatta, se la trova; poi l’eccezione continua a propagarsi.

Passa il puntatore restituito da ::operator new(bytes, alignment) a ::operator delete(p, alignment) con esattamente lo stesso valore di allineamento. Usare l’overload senza allineamento o un valore diverso causa un comportamento indefinito. Anche ::delete p è un’espressione che distrugge l’oggetto, ma salta la deallocazione specifica della classe e quindi qui non sostituisce delete p.

L’esempio riguarda un solo oggetto; per gli array si abbinano new[] e delete[]. outstanding conta le allocazioni riuscite attraverso questa classe che non sono ancora state liberate, non i byte né gli oggetti ancora in vita. Il ritorno a zero non dimostra che la gestione della memoria sia sicura.

Esempi

#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';
}

Risultato

0
1
0

Se l’allocazione riesce, le righe attese sono `0`, `1`, `0`. La piattaforma di destinazione deve supportare `alignas(64)` e soddisfare la condizione di `static_assert`; il supporto dipende dall’implementazione.

Lezioni correlate

  • C++ · Lezione 20 · Avanzato · Versione: 3

Fonti