Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Operatori alokacije i dealokacije specifični za klasu

Klasa može definirati vlastite funkcije operator new i operator delete kako bi upravljala dodjelom i oslobađanjem memorije. Preopterećenja koja primaju std::align_val_t obrađuju poravnanje i moraju surađivati s odgovarajućom funkcijom za oslobađanje memorije.

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

Sintaksa

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;

Funkcije operator new i operator delete specifične za klasu upravljaju memorijom; ne zamjenjuju konstruktore ni destruktore. Statičke su i bez static te ne mogu biti virtualne. Obični new T najprije traži funkciju za alokaciju u klasi; pronađene deklaracije mogu sakriti globalna preopterećenja. ::new T prisiljava globalno pretraživanje, dok ::delete p zaobilazi funkcije dealokacije specifične za klasu. Nemojte ih zaobilaziti ako bi se time narušila kompatibilnost alokacije i dealokacije.

Za alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, prvi pokušaj odabira operator new uključuje argument std::align_val_t. Ako nema odgovarajuće funkcije, odabir se ponavlja bez tog argumenta; za ostale je tipove redoslijed obrnut. Samo postojanje funkcije operator new(std::size_t) specifične za klasu zato ne jamči veće poravnanje: njezina implementacija mora osigurati memoriju prikladnu za objekt koji se stvara.

Osigurajte kompatibilne putove oslobađanja: memoriju dobivenu globalnim ::operator new(n, a) oslobodite globalnim ::operator delete(p, a) uz isto poravnanje. Kod običnog delete prednost preopterećenja koje prima std::align_val_t ovisi o poravnanju tipa. U opsegu klase, nakon primjene te prednosti, preopterećenje bez std::size_t ima prednost pred onim koje prima veličinu. Dealokacija ne bi trebala izbacivati iznimke.

operator new[] i operator delete[] zaseban su par: preopterećenja za pojedinačne objekte ne presreću polja. Ako inicijalizacija ne uspije, izraz new može pozvati odgovarajuću funkciju za oslobađanje memorije. Primjer obuhvaća samo jedan objekt; oba puta alokacije delegiraju globalnom poravnatom preopterećenju, a oba puta oslobađanja njegovu ekvivalentu.

Referentni identifikatori obuhvaćeni ovim unosom: Class-specific operator new/delete and matching aligned overloads.

Primjeri

#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';
}

Rezultat

42 1 1

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori