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.