CKTIS / C++
Klasowe operatory alokacji i zwalniania pamięci
Klasa może definiować własne operator new i operator delete, aby sterować pozyskiwaniem i zwalnianiem pamięci. Przeciążenia z std::align_val_t obsługują wyrównanie; muszą współpracować z właściwą funkcją zwalniającą pamięć.
Wersja: C++23; repository compiler flag, production runtime not attested
Składnia
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;Klasowe operator new i operator delete zarządzają pamięcią, nie zastępują konstruktora ani destruktora. Są statyczne nawet bez static i nie mogą być wirtualne. Zwykłe new T szuka funkcji alokującej najpierw w klasie; znalezione deklaracje mogą ukryć globalne przeciążenia. ::new T wymusza wyszukiwanie globalne, a ::delete p pomija klasowe funkcje zwalniające. Nie omijaj ich, jeśli naruszyłoby to zgodność sposobów alokacji i zwalniania.
Dla alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__ pierwsza próba wyboru operator new uwzględnia argument std::align_val_t. Jeśli nie ma dopasowania, następuje ponowna próba bez niego; dla pozostałych typów kolejność jest odwrotna. Samo istnienie klasowego operator new(std::size_t) nie zapewnia więc większego wyrównania: jego implementacja musi zapewnić pamięć odpowiednią dla tworzonego obiektu.
Zapewnij zgodne ścieżki zwalniania: pamięć uzyskaną przez globalne ::operator new(n, a) zwalniaj przez ::operator delete(p, a) z tym samym wyrównaniem. Przy zwykłym delete preferencja przeciążenia z std::align_val_t zależy od wyrównania typu. W zakresie klasy, po uwzględnieniu tej preferencji, wariant bez std::size_t wygrywa z wariantem zawierającym rozmiar. Zwalnianie pamięci nie powinno zgłaszać wyjątków.
operator new[] i operator delete[] stanowią osobną parę: przeciążenia dla pojedynczych obiektów nie przechwytują tablic. Przy nieudanej inicjalizacji wyrażenie new może wywołać odpowiednią funkcję zwalniającą pamięć. Przykład obejmuje wyłącznie pojedynczy obiekt; obie ścieżki alokacji delegują do globalnego przeciążenia z wyrównaniem, a obie ścieżki zwalniania do jego odpowiednika.
Identyfikatory objęte tym wpisem: Class-specific operator new/delete and matching aligned overloads.
Przykłady
#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';
}
Wynik
42 1 1
Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.