Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Operatori di allocazione e deallocazione specifici della classe

Una classe può definire le proprie funzioni operator new e operator delete per controllare l’allocazione e il rilascio della memoria. Gli overload che accettano std::align_val_t gestiscono l’allineamento e devono essere compatibili con la funzione di rilascio appropriata.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

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;

Le funzioni operator new e operator delete specifiche della classe gestiscono la memoria; non sostituiscono costruttori o distruttori. Sono statiche anche senza static e non possono essere virtuali. Un normale new T cerca prima la funzione di allocazione nella classe; le dichiarazioni trovate possono nascondere gli overload globali. ::new T forza la ricerca globale, mentre ::delete p evita le funzioni di deallocazione specifiche della classe. Non evitarle se ciò comprometterebbe la compatibilità tra allocazione e deallocazione.

Per alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, il primo tentativo di selezionare operator new include un argomento std::align_val_t. Se non esiste una funzione corrispondente, la selezione viene ripetuta senza tale argomento; per gli altri tipi l’ordine è inverso. La semplice presenza di un operator new(std::size_t) specifico della classe non garantisce quindi un allineamento maggiore: la sua implementazione deve fornire memoria adatta all’oggetto creato.

Predisponi percorsi di rilascio compatibili: la memoria ottenuta tramite il ::operator new(n, a) globale va rilasciata tramite il ::operator delete(p, a) globale con lo stesso allineamento. Per un normale delete, la preferenza per un overload che accetta std::align_val_t dipende dall’allineamento del tipo. Nell’ambito della classe, dopo aver applicato tale preferenza, prevale l’overload senza std::size_t rispetto a quello che accetta una dimensione. La deallocazione non dovrebbe generare eccezioni.

operator new[] e operator delete[] costituiscono una coppia distinta: gli overload per i singoli oggetti non intercettano gli array. Se l’inizializzazione non riesce, l’espressione new può invocare una funzione di deallocazione appropriata. L’esempio riguarda un solo oggetto; entrambi i percorsi di allocazione delegano all’overload globale con allineamento ed entrambi i percorsi di rilascio al corrispondente.

Identificatori di riferimento trattati in questa voce: Class-specific operator new/delete and matching aligned overloads.

Esempi

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

Risultato

42 1 1

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti