WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Klassenspezifische Allokations- und Freigabeoperatoren

Eine Klasse kann eigene operator-new- und operator-delete-Funktionen definieren, um die Speicherbeschaffung und -freigabe zu steuern. Überladungen mit std::align_val_t behandeln die Ausrichtung und müssen mit der passenden Freigabefunktion zusammenarbeiten.

Version: 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;

Klassenspezifische operator new- und operator delete-Funktionen verwalten Speicher; sie ersetzen weder Konstruktoren noch Destruktoren. Sie sind auch ohne static statisch und können nicht virtuell sein. Bei gewöhnlichem new T wird zuerst in der Klasse nach der Allokationsfunktion gesucht; dort gefundene Deklarationen können globale Überladungen verdecken. ::new T erzwingt die globale Suche, während ::delete p klassenspezifische Freigabefunktionen umgeht. Umgehe sie nicht, wenn dadurch die Kompatibilität zwischen Allokation und Freigabe verletzt würde.

Für alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__ berücksichtigt der erste Versuch, operator new auszuwählen, ein Argument vom Typ std::align_val_t. Gibt es keine passende Funktion, wird die Auswahl ohne dieses Argument wiederholt; bei anderen Typen ist die Reihenfolge umgekehrt. Allein das Vorhandensein eines klassenspezifischen operator new(std::size_t) garantiert daher keine stärkere Ausrichtung: Seine Implementierung muss Speicher bereitstellen, der für das erzeugte Objekt geeignet ist.

Sorge für zueinander passende Freigabepfade: Speicher, der über das globale ::operator new(n, a) beschafft wurde, ist mit dem globalen ::operator delete(p, a) und derselben Ausrichtung freizugeben. Bei gewöhnlichem delete hängt es von der Ausrichtung des Typs ab, ob eine Überladung mit std::align_val_t bevorzugt wird. Innerhalb der Klasse gewinnt nach Berücksichtigung dieser Präferenz die Überladung ohne std::size_t gegenüber einer Überladung mit Größenangabe. Die Freigabe sollte keine Ausnahmen auslösen.

operator new[] und operator delete[] bilden ein eigenes Paar: Überladungen für einzelne Objekte fangen keine Arrays ab. Scheitert die Initialisierung, kann der new-Ausdruck eine passende Freigabefunktion aufrufen. Das Beispiel behandelt nur ein einzelnes Objekt; beide Allokationspfade delegieren an die globale ausgerichtete Überladung und beide Freigabepfade an deren Gegenstück.

In diesem Eintrag behandelte Referenzbezeichner: Class-specific operator new/delete and matching aligned overloads.

Beispiele

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

Ergebnis

42 1 1

Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.

Quellen