CKTIS / C++
Klassespecifieke operator new en operator delete: overloads met uitlijning
Houd geheugenbeheer en de levensduur van objecten uit elkaar en geef dezelfde uitlijningswaarde door aan de bijbehorende globale functies.
Versie: 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(...) reserveert geheugen en initialiseert daarin vervolgens een object. Bij een geldige, niet-nulle pointer vernietigt delete p met de hier getoonde niet-vernietigende vorm van operator delete eerst het object en geeft daarna het geheugen vrij. Een rechtstreekse aanroep van operator new voert niet automatisch een constructor uit, en een rechtstreekse aanroep van een niet-vernietigende operator delete voert niet automatisch een destructor uit. Een vernietigende operator delete kan daarentegen de destructor vanuit de functiebody aanroepen, ook als die overload rechtstreeks wordt aangeroepen.
Klassespecifieke allocatie- en vrijgavefuncties zijn statische memberfuncties, ook zonder static. Voor één object begint het opzoeken van de naam normaal in de klasse; daar gevonden declaraties verbergen globale functies met dezelfde naam. De expressies ::new en ::delete slaan het zoeken in de klasse over, maar initialiseren of vernietigen het object nog steeds. Omzeil niet één kant van het paar als de andere een aangepast allocatiemechanisme vereist. Arrays gebruiken de aparte vormen new[] en delete[].
Overloads met std::align_val_t uit <new> zijn beschikbaar sinds C++17. Als alignof(T) in C++23 groter is dan __STDCPP_DEFAULT_NEW_ALIGNMENT__, probeert new eerst een passende overload te vinden met een uitlijningsargument. Is er geen match, dan probeert het dat zonder dat argument, binnen dezelfde verzameling declaraties. Op of onder de grens is de volgorde omgekeerd. Bij gewone vrijgavefuncties bepaalt die grens eveneens de voorkeur voor een overload met of zonder uitlijningsparameter.
Roept de memberfunctie ::operator new(bytes, alignment) aan, geef dat blok dan vrij met ::operator delete(ptr, alignment) en dezelfde uitlijningswaarde. De overload zonder uitlijning is geen vervanging: het schenden van deze voorwaarde leidt tot ongedefinieerd gedrag. In het voorbeeld wordt bij een mislukte allocatie std::bad_alloc geworpen voordat de teller wordt verhoogd. Werpt de constructor na de allocatie een uitzondering, dan roept de new-expressie een geschikte vrijgavefunctie aan als die wordt gevonden, en geeft de uitzondering door.
outstanding telt de via dit paar gealloceerde blokken die nog niet zijn vrijgegeven. De teller telt geen bytes of levende objecten, bewijst geen geheugenveiligheid en is niet veilig bij gelijktijdige updates.
Voorbeelden
#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);
}
}
Resultaat
After new: 1 After delete: 0 After constructor throws: 0
Het voorbeeld vereist ondersteuning voor `alignas(64)` en een geslaagde statische controle dat de standaardgrens wordt overschreden. Als beide allocaties slagen, staat `1` voor één nog niet vrijgegeven blok; de twee waarden `0` tonen vrijgave door `delete` en na een uitzondering uit de constructor.
Gerelateerde lessen
- C++ · Les 20 · Gevorderd · Versie: 3