Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

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.

Źródła