Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

operator new e operator delete di classe: scelta degli overload allineati

Distingui la gestione della memoria dalla durata di vita dell’oggetto e passa lo stesso valore di allineamento alle funzioni globali corrispondenti.

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

Sintassi

#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(...) ottiene memoria e poi vi inizializza un oggetto. Per un puntatore valido non nullo, delete p, con la forma non distruttiva di operator delete mostrata qui, distrugge l’oggetto prima di liberarne la memoria. Una chiamata diretta a operator new non esegue automaticamente il costruttore, e una chiamata diretta a un operator delete non distruttivo non esegue automaticamente il distruttore. Un operator delete distruttivo, invece, può chiamare il distruttore nel corpo della funzione anche quando viene chiamato direttamente.

Le funzioni di allocazione e deallocazione specifiche di una classe sono membri statici anche senza static. Per un singolo oggetto, la ricerca del nome normalmente parte dalla classe; le dichiarazioni trovate lì nascondono le funzioni globali omonime. Le espressioni ::new e ::delete saltano la ricerca nella classe, ma inizializzano o distruggono comunque l’oggetto. Non aggirare una funzione della coppia se l’altra richiede un meccanismo di allocazione personalizzato. Per gli array ci sono le forme distinte new[] e delete[].

Gli overload con std::align_val_t da <new> sono disponibili da C++17. In C++23, se alignof(T) supera __STDCPP_DEFAULT_NEW_ALIGNMENT__, new cerca prima una corrispondenza con l’argomento di allineamento; se non la trova, riprova senza quell’argomento tra le stesse dichiarazioni. Alla soglia o al di sotto, l’ordine è inverso. Per le funzioni ordinarie di deallocazione, la stessa soglia determina la preferenza per un overload con o senza il parametro di allineamento.

Se il membro chiama ::operator new(bytes, alignment), libera quel blocco con ::operator delete(ptr, alignment) passando lo stesso valore di allineamento. L’overload senza allineamento non è intercambiabile: violare questo requisito causa un comportamento indefinito. Nell’esempio, se l’allocazione fallisce, viene lanciata std::bad_alloc prima di incrementare il contatore. Se invece il costruttore lancia dopo l’allocazione, l’espressione new chiama una funzione di deallocazione adatta, se la trova, e propaga l’eccezione.

outstanding conta i blocchi allocati tramite questa coppia e non ancora liberati. Non conta byte né oggetti ancora in vita, non dimostra la sicurezza della memoria e non è adatto ad aggiornamenti concorrenti.

Esempi

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

Risultato

After new: 1
After delete: 0
After constructor throws: 0

L’esempio richiede il supporto di `alignas(64)` e che l’asserzione statica confermi il superamento della soglia predefinita. Se entrambe le allocazioni riescono, `1` indica un blocco ancora allocato; i due valori `0` mostrano, rispettivamente, il rilascio tramite `delete` e quello dopo un’eccezione del costruttore.

Lezioni correlate

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

Fonti