KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Klasse-specifieke operatoren voor allocatie en vrijgave

Een klasse kan eigen operator new- en operator delete-functies definiëren om de toewijzing en vrijgave van geheugen te regelen. Overloads met std::align_val_t verwerken de uitlijning en moeten samenwerken met de juiste vrijgavefunctie.

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

Syntax

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;

Klasse-specifieke operator new- en operator delete-functies beheren geheugen; ze vervangen geen constructors of destructors. Ze zijn statisch, ook zonder static, en kunnen niet virtueel zijn. Gewoon new T zoekt eerst in de klasse naar de allocatiefunctie; gevonden declaraties kunnen globale overloads verbergen. ::new T dwingt globaal zoeken af, terwijl ::delete p klasse-specifieke vrijgavefuncties omzeilt. Omzeil ze niet als dat de compatibiliteit tussen allocatie en vrijgave verbreekt.

Voor alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__ bevat de eerste poging om operator new te selecteren een argument van het type std::align_val_t. Als er geen overeenkomst is, wordt opnieuw geselecteerd zonder dat argument; voor andere typen is de volgorde omgekeerd. Alleen een klasse-specifieke operator new(std::size_t) hebben garandeert dus geen sterkere uitlijning: de implementatie moet geheugen leveren dat geschikt is voor het gemaakte object.

Zorg voor compatibele vrijgaveroutes: geef geheugen dat via de globale ::operator new(n, a) is verkregen vrij via de globale ::operator delete(p, a) met dezelfde uitlijning. Bij gewone delete hangt de voorkeur voor een overload met std::align_val_t af van de uitlijning van het type. Binnen de klasse wint, na toepassing van die voorkeur, de overload zonder std::size_t van de overload met een grootte. Deallocatie hoort geen uitzonderingen te veroorzaken.

operator new[] en operator delete[] vormen een afzonderlijk paar: overloads voor losse objecten onderscheppen geen arrays. Als initialisatie mislukt, kan de new-expressie een passende vrijgavefunctie aanroepen. Het voorbeeld behandelt alleen één object; beide allocatieroutes delegeren aan de globale uitgelijnde overload en beide vrijgaveroutes aan de bijbehorende tegenhanger.

Referentie-identificatoren die in dit item worden behandeld: Class-specific operator new/delete and matching aligned overloads.

Voorbeelden

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

Resultaat

42 1 1

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen