CKTIS / C++
Triedne operator new a operator delete: výber preťažení podľa zarovnania
Oddeľ správu pamäte od životnosti objektu a odovzdaj tú istú hodnotu zarovnania zodpovedajúcim globálnym funkciám.
Verzia: 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(...) najprv získa pamäť a potom v nej inicializuje objekt. Pre platný nenulový ukazovateľ delete p v uvedenom variante bez ničiaceho operator delete najprv zničí objekt a až potom uvoľní pamäť. Priame volanie operator new automaticky nespustí konštruktor a priame volanie neničiaceho operator delete automaticky nespustí deštruktor. Ničiaci operator delete však môže zavolať deštruktor v tele funkcie aj pri priamom volaní.
Triedne alokačné a dealokačné funkcie sú statické členské funkcie aj bez static. Pri jednom objekte sa názov zvyčajne hľadá najprv v triede; nájdené deklarácie skryjú globálne funkcie s rovnakým názvom. Výrazy ::new a ::delete preskočia vyhľadávanie v triede, ale objekt naďalej inicializujú alebo zničia. Neobchádzaj jednu stranu dvojice, ak druhá vyžaduje vlastný mechanizmus alokácie. Polia používajú samostatné formy new[] a delete[].
Preťaženia s std::align_val_t z <new> sú dostupné od C++17. Ak v C++23 alignof(T) prekročí __STDCPP_DEFAULT_NEW_ALIGNMENT__, new najprv hľadá zhodu s argumentom zarovnania. Ak ju nenájde, skúsi to bez neho v rovnakej množine deklarácií. Na prahu alebo pod ním je poradie opačné. Pri výbere bežnej dealokačnej funkcie sa podľa rovnakého prahu uprednostňuje preťaženie s parametrom zarovnania alebo bez neho.
Ak členská funkcia volá ::operator new(bytes, alignment), uvoľni daný blok cez ::operator delete(ptr, alignment) s rovnakou hodnotou zarovnania. Variant bez zarovnania nie je náhradou: porušenie tejto podmienky spôsobí nedefinované správanie. Ak alokácia v príklade zlyhá, vyvolá sa std::bad_alloc ešte pred zvýšením počítadla. Ak konštruktor vyvolá výnimku po alokácii, výraz new zavolá vhodnú dealokačnú funkciu, ak ju nájde, a výnimku propaguje ďalej.
outstanding počíta bloky alokované touto dvojicou, ktoré ešte neboli uvoľnené. Nepočíta bajty ani živé objekty, nedokazuje bezpečnosť práce s pamäťou a nie je bezpečný pri súbežných aktualizáciách.
Príklady
#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);
}
}
Výsledok
After new: 1 After delete: 0 After constructor throws: 0
Príklad vyžaduje podporu `alignas(64)` a úspešnú statickú kontrolu, že predvolený prah bol prekročený. Ak sa obe alokácie podaria, `1` označuje jeden zatiaľ neuvoľnený blok; dve hodnoty `0` ukazujú uvoľnenie pomocou `delete` a po výnimke z konštruktora.
Súvisiace lekcie
- C++ · Lekcia 20 · Pokročilá · Verzia: 3