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.