CKTIS / C++
Overloadselectie bij uitgelijnde geheugentoewijzing
Leer hoe C++23 klassespecifieke overloads van `operator new` en `operator delete` kiest en waarom de twee globale aanroepen dezelfde uitlijningswaarde moeten krijgen.
Versie: ISO C++23; implementation support may vary
Syntax
// Class members for single-object allocation and deallocation:
static void* operator new(std::size_t bytes, std::align_val_t alignment);
static void operator delete(void* p, std::align_val_t alignment) noexcept;
// Expressions that manage the lifetime of a T object:
T* p = new T{};
delete p;
// Direct calls that manage raw storage:
void* raw = ::operator new(bytes, alignment);
::operator delete(raw, alignment);new T{} reserveert geheugen en initialiseert daarin een object van type T. In het getoonde geval vernietigt delete p het object en geeft het daarna het geheugen vrij. Rechtstreekse aanroepen van operator new en operator delete beheren ruw geheugen: ze roepen de constructor of destructor van T niet aan.
In C++23 zoekt new T{} eerst in de klasse naar operator new. Declaraties die daar worden gevonden, verbergen de globale overloads; ::new T{} slaat het klassebereik over. Als alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, geeft de eerste poging tot overloadselectie alignof(T) als std::align_val_t mee na de grootte. Past geen enkele functie, dan volgt een poging zonder het uitlijningsargument. Voor andere typen is de volgorde omgekeerd. Ook een klasseoverload zonder uitlijningsparameter moet correct uitgelijnd geheugen teruggeven.
Voor het getoonde type zoekt delete p naar operator delete in de klasse en zoekt het alleen globaal als het daar geen declaratie vindt. De vrijgavefunctie wordt onafhankelijk van de toewijzingsfunctie gekozen: boven dezelfde drempel heeft de vorm met std::align_val_t de voorkeur, anders de vorm zonder die parameter. Gooit de constructor na een geslaagde toewijzing een uitzondering, dan roept de new-expressie een geschikte vrijgavefunctie aan als die wordt gevonden. Daarna propageert de uitzondering verder.
Geef de pointer die ::operator new(bytes, alignment) teruggeeft door aan ::operator delete(p, alignment) met exact dezelfde uitlijningswaarde. De variant zonder uitlijning of een andere uitlijningswaarde leidt tot ongedefinieerd gedrag. ::delete p is nog steeds een expressie die het object vernietigt, maar omzeilt de klassespecifieke vrijgave en kan hier dus niet in de plaats komen van delete p.
Dit voorbeeld behandelt één object; voor arrays horen new[] en delete[] bij elkaar. outstanding telt geslaagde toewijzingen via deze klasse die nog niet zijn vrijgegeven, niet het aantal bytes of nog levende objecten. Als de teller terugkeert naar nul, bewijst dat niet dat het geheugenbeheer veilig is.
Voorbeelden
#include <cstddef>
#include <iostream>
#include <new>
struct alignas(64) Block {
inline static std::size_t outstanding = 0;
int value{};
static void* operator new(std::size_t bytes, std::align_val_t alignment) {
void* p = ::operator new(bytes, alignment);
++outstanding;
return p;
}
static void operator delete(void* p, std::align_val_t alignment) noexcept {
if (p == nullptr) return;
::operator delete(p, alignment);
--outstanding;
}
};
static_assert(alignof(Block) > __STDCPP_DEFAULT_NEW_ALIGNMENT__);
int main() {
std::cout << Block::outstanding << '\n';
Block* p = new Block{};
std::cout << Block::outstanding << '\n';
delete p;
std::cout << Block::outstanding << '\n';
}Resultaat
0 1 0
Als de toewijzing slaagt, zijn de verwachte regels `0`, `1`, `0`. Het doelplatform moet `alignas(64)` ondersteunen en voldoen aan de voorwaarde in `static_assert`; ondersteuning hangt af van de implementatie.
Gerelateerde lessen
- C++ · Les 20 · Gevorderd · Versie: 3