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

CKTIS / C++

Výber preťaženia pri zarovnanej alokácii

Zisti, ako C++23 vyberá triedne preťaženia `operator new` a `operator delete` a prečo obe volania zodpovedajúcich globálnych funkcií musia dostať rovnakú hodnotu zarovnania.

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

Syntax

// Class members for single-object allocation and deallocation:
static void* operator new(std::size_t bytes, std::align_val_t alignment);
static void operator delete(void* p, std::align_val_t alignment) noexcept;

// Expressions that manage the lifetime of a T object:
T* p = new T{};
delete p;

// Direct calls that manage raw storage:
void* raw = ::operator new(bytes, alignment);
::operator delete(raw, alignment);

new T{} získa pamäť a inicializuje v nej objekt typu T. V uvedenom prípade delete p objekt zničí a potom uvoľní jeho pamäť. Priame volania operator new a operator delete spravujú surovú pamäť: nevolajú konštruktor ani deštruktor typu T.

V C++23 hľadá new T{} názov operator new najprv v triede. Deklarácie nájdené v triede zakryjú globálne preťaženia; ::new T{} preskočí oblasť platnosti triedy. Ak alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, prvý pokus o výber preťaženia odovzdá po veľkosti hodnotu alignof(T) ako std::align_val_t. Ak sa nenájde vhodná funkcia, nasleduje pokus bez zarovnania. Pri ostatných typoch je poradie opačné. Aj triedne preťaženie bez parametra zarovnania musí vrátiť správne zarovnanú pamäť.

Pre uvedený typ hľadá delete p názov operator delete v triede a globálne ho hľadá, len ak v triede nenájde žiadnu deklaráciu. Funkcia na uvoľnenie pamäte sa vyberá nezávisle od alokačnej funkcie: nad rovnakou hranicou má prednosť verzia s std::align_val_t, inak verzia bez neho. Ak konštruktor po úspešnej alokácii vyvolá výnimku, výraz new zavolá vhodnú funkciu na uvoľnenie pamäte, ak ju nájde, a výnimka sa šíri ďalej.

Ukazovateľ vrátený z ::operator new(bytes, alignment) odovzdaj funkcii ::operator delete(p, alignment) s presne rovnakou hodnotou zarovnania. Použitie preťaženia bez zarovnania alebo inej hodnoty vedie k nedefinovanému správaniu. ::delete p je stále výraz, ktorý zničí objekt, ale obíde triednu funkciu na uvoľnenie pamäte, takže tu nenahrádza delete p.

Príklad sa týka jedného objektu; pre polia sa párujú new[] a delete[]. outstanding počíta úspešné alokácie prostredníctvom tejto triedy, ktoré ešte neboli uvoľnené, nie bajty ani živé objekty. Návrat na nulu nedokazuje bezpečnú správu pamäte.

Príklady

#include <cstddef>
#include <iostream>
#include <new>

struct alignas(64) Block {
    inline static std::size_t outstanding = 0;
    int value{};

    static void* operator new(std::size_t bytes, std::align_val_t alignment) {
        void* p = ::operator new(bytes, alignment);
        ++outstanding;
        return p;
    }

    static void operator delete(void* p, std::align_val_t alignment) noexcept {
        if (p == nullptr) return;
        ::operator delete(p, alignment);
        --outstanding;
    }
};

static_assert(alignof(Block) > __STDCPP_DEFAULT_NEW_ALIGNMENT__);

int main() {
    std::cout << Block::outstanding << '\n';
    Block* p = new Block{};
    std::cout << Block::outstanding << '\n';
    delete p;
    std::cout << Block::outstanding << '\n';
}

Výsledok

0
1
0

Pri úspešnej alokácii sa očakávajú riadky `0`, `1`, `0`. Cieľová platforma musí podporovať `alignas(64)` a splniť podmienku v `static_assert`; podpora závisí od implementácie.

Súvisiace lekcie

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

Zdroje