Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

operator new i operator delete u klasi: odabir preopterećenja prema poravnanju

Razdvoji upravljanje memorijom od životnog vijeka objekta i odgovarajućim globalnim funkcijama proslijedi istu vrijednost poravnanja.

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

Sintaksa

#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(...) pribavlja memoriju, a zatim u njoj inicijalizira objekt. Za valjani pokazivač koji nije nul-pokazivač, delete p s ovdje prikazanim nedestruktivnim oblikom operator delete prvo uništava objekt, a zatim oslobađa memoriju. Izravni poziv funkcije operator new ne pokreće automatski konstruktor, a izravni poziv nedestruktivnog oblika operator delete ne pokreće automatski destruktor. Destruktivni oblik operator delete ipak može pozvati destruktor u tijelu funkcije, čak i kada se pozove izravno.

Funkcije za alokaciju i oslobađanje memorije specifične za klasu statičke su funkcije članice čak i bez static. Za pojedinačni objekt ime se obično prvo traži u klasi; tamo pronađene deklaracije skrivaju istoimene globalne funkcije. Izrazi ::new i ::delete preskaču pretraživanje klase, ali i dalje inicijaliziraju odnosno uništavaju objekt. Ne zaobilazi jednu stranu para ako se druga oslanja na vlastiti mehanizam alokacije. Polja koriste zasebne oblike new[] i delete[].

Preopterećenja sa std::align_val_t iz <new> dostupna su od C++17. U C++23, ako alignof(T) premašuje __STDCPP_DEFAULT_NEW_ALIGNMENT__, new prvo traži odgovarajuće preopterećenje s argumentom poravnanja. Ako ga ne pronađe, pokušava bez tog argumenta u istom skupu deklaracija. Na pragu ili ispod njega redoslijed je obrnut. Pri odabiru uobičajene funkcije za oslobađanje isti prag određuje ima li prednost preopterećenje s parametrom poravnanja ili bez njega.

Ako funkcija članica zove ::operator new(bytes, alignment), oslobodi taj blok pozivom ::operator delete(ptr, alignment) s istom vrijednošću poravnanja. Varijanta bez poravnanja nije zamjena: kršenje tog zahtjeva dovodi do nedefiniranog ponašanja. Ako alokacija u primjeru ne uspije, baca se std::bad_alloc prije povećanja brojača. Ako konstruktor baci iznimku nakon alokacije, izraz new poziva odgovarajuću funkciju za oslobađanje ako je pronađe, a zatim prosljeđuje iznimku.

outstanding broji blokove alocirane putem tog para koji još nisu oslobođeni. Ne broji bajtove ni žive objekte, ne dokazuje sigurnost rada s memorijom i nije siguran za istovremena ažuriranja.

Primjeri

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

Rezultat

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

Primjer zahtijeva podršku za `alignas(64)` i uspješnu statičku provjeru da je zadani prag premašen. Ako obje alokacije uspiju, `1` označava jedan dosad neoslobođeni blok; dvije vrijednosti `0` pokazuju oslobađanje pomoću `delete` odnosno nakon iznimke iz konstruktora.

Povezane lekcije

  • C++ · Lekcija 20 · Napredno · Verzija: 3

Izvori