CKTIS / C++
Třídní operator new a operator delete: výběr přetížení podle zarovnání
Odděl správu paměti od životnosti objektu a předej odpovídajícím globálním funkcím tutéž hodnotu zarovnání.
Verze: ISO C++23; implementation support may vary
Syntaxe
#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(...) nejprve získá paměť a poté v ní inicializuje objekt. Pro platný nenulový ukazatel delete p v zde uvedené variantě bez ničícího operator delete nejprve zničí objekt a potom uvolní paměť. Přímé volání operator new automaticky nespustí konstruktor a přímé volání neničícího operator delete automaticky nespustí destruktor. Ničící operator delete však může destruktor zavolat v těle funkce i při přímém volání.
Třídní alokační a dealokační funkce jsou statické členské funkce i bez zápisu static. Pro jeden objekt vyhledávání jména obvykle začíná ve třídě; nalezené deklarace zakryjí stejnojmenné globální funkce. Výrazy ::new a ::delete vyhledávání ve třídě přeskočí, ale objekt stále inicializují nebo zničí. Neobcházej jednu stranu dvojice, pokud druhá vyžaduje vlastní způsob alokace. Pole používají samostatné formy new[] a delete[].
Přetížení s std::align_val_t z <new> jsou dostupná od C++17. Pokud v C++23 alignof(T) překročí __STDCPP_DEFAULT_NEW_ALIGNMENT__, new nejprve hledá vhodné přetížení s argumentem zarovnání. Pokud žádné nenajde, zkusí to bez něj ve stejné množině deklarací. Při dosažení prahu nebo pod ním je pořadí opačné. Při výběru běžné dealokační funkce se podle stejného prahu upřednostní přetížení s parametrem zarovnání, nebo bez něj.
Jestliže členská funkce volá ::operator new(bytes, alignment), uvolni blok voláním ::operator delete(ptr, alignment) se stejnou hodnotou zarovnání. Varianta bez zarovnání není náhradou: porušení této podmínky vede k nedefinovanému chování. Selže-li v příkladu alokace, vyvolá se std::bad_alloc ještě před zvýšením čítače. Pokud konstruktor vyvolá výjimku po alokaci, výraz new zavolá vhodnou dealokační funkci, pokud ji najde, a nechá výjimku šířit dál.
outstanding počítá bloky alokované touto dvojicí, které zatím nebyly uvolněny. Nepočítá bajty ani živé objekty, nedokládá bezpečnost práce s pamětí a není bezpečný pro souběžné aktualizace.
Pří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ýsledek
After new: 1 After delete: 0 After constructor throws: 0
Příklad vyžaduje podporu `alignas(64)` a úspěšnou statickou kontrolu, že je výchozí práh překročen. Pokud obě alokace uspějí, `1` značí jeden dosud neuvolněný blok; dvě hodnoty `0` ukazují uvolnění pomocí `delete` a po výjimce z konstruktoru.
Související lekce
- C++ · Lekce 20 · Pokročilá · Verze: 3