Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Klasowe operator new i operator delete: dobór przeciążeń według wyrównania

Oddziel przydzielanie pamięci od czasu życia obiektu i dobierz parę przeciążeń, która przekazuje tę samą wartość wyrównania do funkcji globalnych.

Wersja: ISO C++23; implementation support may vary

Składnia

#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;
};

Wyrażenie new T(...) najpierw uzyskuje pamięć, a potem inicjalizuje w niej obiekt. Dla poprawnego, niepustego wskaźnika delete p w omawianym wariancie bez niszczącego operator delete najpierw niszczy obiekt, a potem zwalnia pamięć. Bezpośrednie wywołanie operator new nie uruchamia automatycznie konstruktora, a bezpośrednie wywołanie nieniszczącego operator delete nie uruchamia automatycznie destruktora. Niszczący operator delete może jednak wywołać destruktor w ciele funkcji, nawet gdy zostanie wywołany bezpośrednio.

Klasowe funkcje alokacji i dealokacji są statycznymi składowymi nawet bez słowa static. Dla pojedynczego obiektu wyszukiwanie zwykle zaczyna się w klasie; znalezione tam deklaracje przesłaniają funkcje globalne o tej samej nazwie. Wyrażenia ::new i ::delete pomijają wyszukiwanie w klasie, ale nadal inicjalizują lub niszczą obiekt. Nie omijaj w ten sposób połowy pary, jeśli druga wymaga własnego mechanizmu alokacji. Tablice używają osobnych form new[] i delete[].

Przeciążenia z std::align_val_t z <new> są dostępne od C++17. W C++23, gdy alignof(T) przekracza __STDCPP_DEFAULT_NEW_ALIGNMENT__, new najpierw próbuje dobrać przeciążenie z argumentem wyrównania, a przy braku dopasowania próbuje bez niego w tym samym zbiorze deklaracji. Dla wyrównania nieprzekraczającego progu kolejność jest odwrotna. Przy wyborze zwykłej funkcji dealokacji preferowany jest odpowiednio wariant z parametrem wyrównania lub bez niego.

Jeśli klasowa funkcja wywołuje ::operator new(bytes, alignment), zwolnij ten blok przez ::operator delete(ptr, alignment) z tą samą wartością wyrównania. Wariant bez wyrównania nie jest zamiennikiem: naruszenie tego warunku prowadzi do niezdefiniowanego zachowania. W przykładzie niepowodzenie alokacji zgłasza std::bad_alloc przed zwiększeniem licznika. Jeśli natomiast konstruktor zgłosi wyjątek po przydzieleniu pamięci, wyrażenie new zwolni ją przez odpowiednią funkcję dealokacji, o ile ją znajdzie, i przekaże wyjątek dalej.

Licznik outstanding pokazuje liczbę przydzielonych, ale jeszcze niezwolnionych bloków obsługiwanych przez tę parę funkcji. Nie liczy bajtów ani żywych obiektów, nie dowodzi bezpieczeństwa pamięci i nie jest przystosowany do współbieżnych aktualizacji.

Przykłady

#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);
    }
}

Wynik

After new: 1
After delete: 0
After constructor throws: 0

Przykład wymaga obsługi `alignas(64)` i przejścia asercji statycznej potwierdzającej przekroczenie domyślnego progu. Jeśli obie alokacje się powiodą, `1` oznacza jeden niezwolniony blok, a oba wyniki `0` pokazują zwolnienie pamięci: najpierw przez `delete`, potem po wyjątku z konstruktora.

Powiązane lekcje

  • C++ · Lekcja 20 · Zaawansowany · Wersja: 3

Źródła