CKTIS / C++
Klassenspezifisches operator new und operator delete: Überladungen für die Ausrichtung
Trenne Speicherverwaltung und Objektlebensdauer und übergib denselben Ausrichtungswert an die zusammengehörigen globalen Funktionen.
Version: ISO C++23; implementation support may vary
Syntax
#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(...) beschafft zunächst Speicher und initialisiert darin anschließend ein Objekt. Bei einem gültigen, von null verschiedenen Zeiger zerstört delete p in der hier gezeigten Variante ohne zerstörendes operator delete zuerst das Objekt und gibt dann den Speicher frei. Ein direkter Aufruf von operator new ruft nicht automatisch einen Konstruktor auf, und ein direkter Aufruf eines nicht zerstörenden operator delete ruft nicht automatisch einen Destruktor auf. Ein zerstörendes operator delete kann dagegen auch bei einem direkten Aufruf den Destruktor in seinem Funktionsrumpf aufrufen.
Klassenspezifische Allokations- und Freigabefunktionen sind auch ohne static statische Memberfunktionen. Für ein einzelnes Objekt beginnt die Namenssuche normalerweise in der Klasse; dort gefundene Deklarationen verdecken gleichnamige globale Funktionen. Die Ausdrücke ::new und ::delete umgehen die Suche in der Klasse, initialisieren oder zerstören das Objekt aber weiterhin. Umgehe nicht eine Seite des Paars, wenn die andere einen eigenen Allokationsmechanismus voraussetzt. Arrays nutzen die separaten Formen new[] und delete[].
Überladungen mit std::align_val_t aus <new> gibt es seit C++17. Überschreitet alignof(T) in C++23 den Wert __STDCPP_DEFAULT_NEW_ALIGNMENT__, sucht new zuerst mit einem Ausrichtungsargument nach einer passenden Überladung und versucht es bei fehlender Übereinstimmung ohne dieses Argument in derselben Kandidatenmenge. Am oder unterhalb des Grenzwerts ist die Reihenfolge umgekehrt. Bei gewöhnlichen Freigabefunktionen wird entsprechend eine Überladung mit oder ohne Ausrichtungsparameter bevorzugt.
Ruft die Memberfunktion ::operator new(bytes, alignment) auf, muss derselbe Block mit ::operator delete(ptr, alignment) und demselben Ausrichtungswert freigegeben werden. Die Variante ohne Ausrichtungsparameter ist kein Ersatz: Ein Verstoß führt zu undefiniertem Verhalten. Scheitert im Beispiel die Allokation, wird std::bad_alloc ausgelöst, bevor der Zähler steigt. Wirft der Konstruktor nach der Allokation eine Ausnahme, ruft der new-Ausdruck eine passende Freigabefunktion auf, sofern er eine findet, und gibt die Ausnahme weiter.
outstanding zählt die über dieses Paar allokierten, noch nicht freigegebenen Blöcke. Der Zähler erfasst weder Bytes noch lebende Objekte, belegt keine Speichersicherheit und eignet sich nicht für gleichzeitige Aktualisierungen.
Beispiele
#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);
}
}
Ergebnis
After new: 1 After delete: 0 After constructor throws: 0
Das Beispiel setzt Unterstützung für `alignas(64)` voraus. Die statische Prüfung muss bestätigen, dass die Standardgrenze überschritten ist. Gelingen beide Allokationen, steht `1` für einen noch nicht freigegebenen Block; die beiden Werte `0` zeigen die Freigabe durch `delete` und nach einer Konstruktorausnahme.
Zugehörige Lektionen
- C++ · Lektion 20 · Fortgeschritten · Version: 3