Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Výběr přetížení při zarovnané alokaci

Zjisti, jak C++23 vybírá třídní přetížení `operator new` a `operator delete` a proč obě volání odpovídajících globálních funkcí musí dostat stejnou hodnotu zarovnání.

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

Syntaxe

// 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íská paměť a inicializuje v ní objekt typu T. V uvedeném případě delete p objekt zničí a poté paměť uvolní. Přímá volání operator new a operator delete spravují surovou paměť: nevolají konstruktor ani destruktor typu T.

V C++23 hledá new T{} jméno operator new nejprve v rozsahu třídy. Tam nalezené deklarace zakryjí globální přetížení; ::new T{} rozsah třídy přeskočí. Pokud alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, první pokus o výběr přetížení předá alignof(T) jako std::align_val_t za velikostí. Nenajde-li se odpovídající funkce, následuje pokus bez zarovnání. U ostatních typů je pořadí opačné. I třídní přetížení bez parametru zarovnání musí vrátit správně zarovnanou paměť.

Pro uvedený typ hledá delete p jméno operator delete ve třídě. V globálním rozsahu hledá, jen pokud ve třídě nenajde žádnou deklaraci. Funkce pro uvolnění paměti se vybírá nezávisle na alokační funkci: nad stejnou hranicí má přednost varianta s std::align_val_t, jinak varianta bez něj. Vyvolá-li konstruktor po úspěšné alokaci výjimku, výraz new zavolá vhodnou funkci pro uvolnění, pokud ji najde, a výjimka se šíří dál.

Ukazatel vrácený z ::operator new(bytes, alignment) předej funkci ::operator delete(p, alignment) s přesně stejnou hodnotou zarovnání. Použití varianty bez zarovnání nebo jiné hodnoty vede k nedefinovanému chování. ::delete p je stále výraz, který zničí objekt, ale obejde třídní funkci pro uvolnění paměti, takže zde nenahrazuje delete p.

Příklad se týká jediného objektu; pro pole patří k sobě new[] a delete[]. outstanding počítá úspěšné alokace prostřednictvím této třídy, které ještě nebyly uvolněny, nikoli bajty ani živé objekty. Návrat na nulu nedokazuje bezpečnou správu paměti.

Pří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ýsledek

0
1
0

Při úspěšné alokaci se očekávají řádky `0`, `1`, `0`. Cílová platforma musí podporovat `alignas(64)` a splnit podmínku v `static_assert`; podpora závisí na implementaci.

Související lekce

  • C++ · Lekce 20 · Pokročilá · Verze: 3

Zdroje