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

CKTIS / C++

Operátory alokace a dealokace specifické pro třídu

Třída může definovat vlastní funkce operator new a operator delete a řídit tak přidělování a uvolňování paměti. Přetížení přijímající std::align_val_t řeší zarovnání a musí spolupracovat s odpovídající funkcí pro uvolnění paměti.

Verze: C++23; repository compiler flag, production runtime not attested

Syntaxe

static void* operator new(std::size_t n);
static void operator delete(void* p) noexcept;
static void* operator new(std::size_t n, std::align_val_t a);
static void operator delete(void* p, std::align_val_t a) noexcept;

Funkce operator new a operator delete specifické pro třídu spravují paměť; nenahrazují konstruktory ani destruktory. Jsou statické, i když není uvedeno static, a nemohou být virtuální. Běžné new T hledá alokační funkci nejprve ve třídě; nalezená deklarace může skrýt globální přetížení. ::new T vynutí globální vyhledávání, zatímco ::delete p obejde funkce dealokace specifické pro třídu. Neobcházejte je, pokud by tím byla narušena kompatibilita alokace a dealokace.

Pro alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__ zahrnuje první pokus o výběr operator new argument std::align_val_t. Pokud odpovídající funkce neexistuje, výběr se opakuje bez tohoto argumentu; u ostatních typů je pořadí opačné. Samotná přítomnost operator new(std::size_t) specifického pro třídu tedy nezaručuje větší zarovnání: jeho implementace musí poskytnout paměť vhodnou pro vytvářený objekt.

Zajistěte kompatibilní cesty uvolnění: paměť získanou pomocí globálního ::operator new(n, a) uvolněte pomocí globálního ::operator delete(p, a) se stejným zarovnáním. U běžného delete závisí přednost přetížení přijímajícího std::align_val_t na zarovnání typu. V rámci třídy po uplatnění této preference vítězí přetížení bez std::size_t nad přetížením, které přijímá velikost. Dealokace by neměla vyvolávat výjimky.

operator new[] a operator delete[] tvoří samostatný pár: přetížení pro jednotlivé objekty nezachytí pole. Pokud inicializace selže, výraz new může zavolat vhodnou funkci pro uvolnění paměti. Příklad se týká pouze jednoho objektu; obě alokační cesty delegují na globální přetížení se zarovnáním a obě cesty uvolnění na jeho protějšek.

Referenční identifikátory zahrnuté v tomto hesle: Class-specific operator new/delete and matching aligned overloads.

Příklady

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

// This declaration requires implementation support for 64-byte alignment.
// C++23 does not guarantee that support.
struct alignas(64) Node final {
    int value = 42;
    inline static int allocations = 0;
    inline static int deallocations = 0;

    static void* operator new(std::size_t n) {
        return Node::operator new(n, std::align_val_t{alignof(Node)});
    }

    static void* operator new(std::size_t n, std::align_val_t a) {
        void* p = ::operator new(n, a);
        ++allocations;
        return p;
    }

    static void operator delete(void* p) noexcept {
        Node::operator delete(p, std::align_val_t{alignof(Node)});
    }

    static void operator delete(void* p, std::align_val_t a) noexcept {
        ++deallocations;
        ::operator delete(p, a);
    }
};

int main() {
    Node* p = new Node;
    const int value = p->value;
    delete p;
    std::cout << value << ' ' << Node::allocations << ' '
              << Node::deallocations << '\n';
}

Výsledek

42 1 1

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje