Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Dobór przeciążeń przy alokacji z wyrównaniem

Zobacz, jak C++23 wybiera klasowe `operator new` i `operator delete` oraz dlaczego obie funkcje muszą przekazać tę samą wartość wyrównania do pary funkcji globalnych.

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

Składnia

// 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);

Wyrażenie new T{} uzyskuje pamięć i inicjalizuje w niej obiekt T. W pokazanym przypadku delete p niszczy obiekt, a następnie zwalnia pamięć. Bezpośrednie wywołania operator new i operator delete zarządzają surową pamięcią: nie wywołują konstruktora ani destruktora T.

W C++23 przy new T{} nazwy operator new szuka się najpierw w klasie. Znalezione deklaracje ukrywają przeciążenia globalne; ::new T{} pomija zakres klasy. Gdy alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, pierwsza próba doboru przeciążenia przekazuje po rozmiarze wartość alignof(T) jako std::align_val_t; jeśli nie ma dopasowania, druga próba pomija wyrównanie. Dla pozostałych typów kolejność jest odwrotna. Klasowy wariant bez parametru wyrównania nadal musi zwrócić właściwie wyrównaną pamięć.

Zwykłe delete p dla pokazanego typu szuka operator delete w klasie, a jeśli go tam nie znajdzie, szuka globalnie. Funkcję zwalniającą wybiera niezależnie od funkcji alokującej: powyżej tego samego progu preferuje wariant ze std::align_val_t, a w pozostałych przypadkach wariant bez niego. Jeśli konstruktor rzuci wyjątek po udanej alokacji, wyrażenie new wywoła odpowiednią funkcję zwalniającą, o ile ją znajdzie, po czym wyjątek będzie dalej propagowany.

Przekaż wskaźnik zwrócony przez ::operator new(bytes, alignment) do ::operator delete(p, alignment) z dokładnie tą samą wartością wyrównania. Wariant bez wyrównania lub z inną wartością powoduje niezdefiniowane zachowanie. Samo ::delete p to nadal wyrażenie niszczące obiekt, ale pomija klasowy mechanizm zwalniania, więc nie zastępuje delete p w tym przykładzie.

Przykład dotyczy pojedynczego obiektu; dla tablic parą jest new[] i delete[]. Licznik outstanding mierzy liczbę udanych alokacji przez tę klasę, których jeszcze nie zwolniono, a nie liczbę bajtów ani żywych obiektów. Powrót do zera nie dowodzi bezpieczeństwa pamięci.

Przykłady

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

Wynik

0
1
0

Po udanej alokacji oczekiwane są trzy wiersze: `0`, `1`, `0`. Wymagane jest wsparcie dla `alignas(64)` i spełnienie warunku `static_assert`; obsługa zależy od implementacji.

Powiązane lekcje

  • C++ · Lekcja 20 · Zaawansowany · Wersja: 3

Źródła