Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Opérateurs d’allocation et de désallocation propres à une classe

Une classe peut définir ses propres fonctions operator new et operator delete afin de contrôler l’allocation et la libération du stockage. Les surcharges prenant std::align_val_t gèrent l’alignement et doivent être compatibles avec la fonction de libération appropriée.

Version : 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;

Les fonctions operator new et operator delete propres à une classe gèrent le stockage ; elles ne remplacent ni les constructeurs ni les destructeurs. Elles sont statiques même sans static et ne peuvent pas être virtuelles. Un new T ordinaire recherche d’abord la fonction d’allocation dans la classe ; les déclarations qui s’y trouvent peuvent masquer les surcharges globales. ::new T impose une recherche globale, tandis que ::delete p contourne les fonctions de désallocation propres à la classe. Ne les contournez pas si cela rompt la compatibilité entre allocation et désallocation.

Pour alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, la première tentative de sélection de operator new inclut un argument std::align_val_t. En l’absence de fonction correspondante, la sélection est réessayée sans cet argument ; pour les autres types, l’ordre est inversé. La simple présence d’un operator new(std::size_t) propre à la classe ne garantit donc pas un alignement supérieur : son implémentation doit fournir un stockage adapté à l’objet créé.

Prévoyez des chemins de libération compatibles : libérez le stockage obtenu via le ::operator new(n, a) global avec le ::operator delete(p, a) global et le même alignement. Pour un delete ordinaire, la préférence accordée à une surcharge prenant std::align_val_t dépend de l’alignement du type. Dans la classe, une fois cette préférence appliquée, la surcharge sans std::size_t l’emporte sur celle qui prend une taille. La désallocation ne devrait pas lancer d’exceptions.

operator new[] et operator delete[] forment une paire distincte : les surcharges pour un objet unique n’interceptent pas les tableaux. Si l’initialisation échoue, l’expression new peut appeler une fonction de désallocation appropriée. L’exemple ne traite qu’un seul objet ; les deux chemins d’allocation délèguent à la surcharge globale avec alignement, et les deux chemins de libération à son équivalent.

Identifiants de référence couverts par cette entrée : Class-specific operator new/delete and matching aligned overloads.

Exemples

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

Résultat

42 1 1

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources