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

CKTIS / C++

Operátory alokácie a dealokácie špecifické pre triedu

Trieda môže definovať vlastné funkcie operator new a operator delete a riadiť tak prideľovanie a uvoľňovanie pamäte. Preťaženia prijímajúce std::align_val_t riešia zarovnanie a musia spolupracovať s príslušnou funkciou na uvoľnenie pamäte.

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

Syntax

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;

Funkcie operator new a operator delete špecifické pre triedu spravujú pamäť; nenahrádzajú konštruktory ani deštruktory. Sú statické aj bez uvedenia static a nemôžu byť virtuálne. Bežné new T hľadá alokačnú funkciu najprv v triede; nájdené deklarácie môžu skryť globálne preťaženia. ::new T vynúti globálne vyhľadávanie, zatiaľ čo ::delete p obíde funkcie dealokácie špecifické pre triedu. Neobchádzajte ich, ak by sa tým narušila kompatibilita alokácie a dealokácie.

Pre alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__ zahŕňa prvý pokus o výber operator new argument std::align_val_t. Ak neexistuje zodpovedajúca funkcia, výber sa zopakuje bez tohto argumentu; pri ostatných typoch je poradie opačné. Samotná existencia operator new(std::size_t) špecifického pre triedu teda nezaručuje väčšie zarovnanie: jeho implementácia musí poskytnúť pamäť vhodnú pre vytváraný objekt.

Zabezpečte kompatibilné cesty uvoľnenia: pamäť získanú pomocou globálneho ::operator new(n, a) uvoľnite pomocou globálneho ::operator delete(p, a) s rovnakým zarovnaním. Pri bežnom delete závisí prednosť preťaženia prijímajúceho std::align_val_t od zarovnania typu. V rámci triedy po uplatnení tejto preferencie víťazí preťaženie bez std::size_t nad preťažením, ktoré prijíma veľkosť. Dealokácia by nemala vyhadzovať výnimky.

operator new[] a operator delete[] tvoria samostatný pár: preťaženia pre jednotlivé objekty nezachytia polia. Ak inicializácia zlyhá, výraz new môže zavolať vhodnú funkciu na uvoľnenie pamäte. Príklad sa týka iba jedného objektu; obe alokačné cesty delegujú na globálne preťaženie so zarovnaním a obe cesty uvoľnenia na jeho náprotivok.

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

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

42 1 1

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje