Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Triedne operator new a operator delete: výber preťažení podľa zarovnania

Oddeľ správu pamäte od životnosti objektu a odovzdaj tú istú hodnotu zarovnania zodpovedajúcim globálnym funkciám.

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

Syntax

#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(...) najprv získa pamäť a potom v nej inicializuje objekt. Pre platný nenulový ukazovateľ delete p v uvedenom variante bez ničiaceho operator delete najprv zničí objekt a až potom uvoľní pamäť. Priame volanie operator new automaticky nespustí konštruktor a priame volanie neničiaceho operator delete automaticky nespustí deštruktor. Ničiaci operator delete však môže zavolať deštruktor v tele funkcie aj pri priamom volaní.

Triedne alokačné a dealokačné funkcie sú statické členské funkcie aj bez static. Pri jednom objekte sa názov zvyčajne hľadá najprv v triede; nájdené deklarácie skryjú globálne funkcie s rovnakým názvom. Výrazy ::new a ::delete preskočia vyhľadávanie v triede, ale objekt naďalej inicializujú alebo zničia. Neobchádzaj jednu stranu dvojice, ak druhá vyžaduje vlastný mechanizmus alokácie. Polia používajú samostatné formy new[] a delete[].

Preťaženia s std::align_val_t z <new> sú dostupné od C++17. Ak v C++23 alignof(T) prekročí __STDCPP_DEFAULT_NEW_ALIGNMENT__, new najprv hľadá zhodu s argumentom zarovnania. Ak ju nenájde, skúsi to bez neho v rovnakej množine deklarácií. Na prahu alebo pod ním je poradie opačné. Pri výbere bežnej dealokačnej funkcie sa podľa rovnakého prahu uprednostňuje preťaženie s parametrom zarovnania alebo bez neho.

Ak členská funkcia volá ::operator new(bytes, alignment), uvoľni daný blok cez ::operator delete(ptr, alignment) s rovnakou hodnotou zarovnania. Variant bez zarovnania nie je náhradou: porušenie tejto podmienky spôsobí nedefinované správanie. Ak alokácia v príklade zlyhá, vyvolá sa std::bad_alloc ešte pred zvýšením počítadla. Ak konštruktor vyvolá výnimku po alokácii, výraz new zavolá vhodnú dealokačnú funkciu, ak ju nájde, a výnimku propaguje ďalej.

outstanding počíta bloky alokované touto dvojicou, ktoré ešte neboli uvoľnené. Nepočíta bajty ani živé objekty, nedokazuje bezpečnosť práce s pamäťou a nie je bezpečný pri súbežných aktualizáciách.

Prí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ýsledok

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

Príklad vyžaduje podporu `alignas(64)` a úspešnú statickú kontrolu, že predvolený prah bol prekročený. Ak sa obe alokácie podaria, `1` označuje jeden zatiaľ neuvoľnený blok; dve hodnoty `0` ukazujú uvoľnenie pomocou `delete` a po výnimke z konštruktora.

Súvisiace lekcie

  • C++ · Lekcia 20 · Pokročilá · Verzia: 3

Zdroje