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

CKTIS / C++

operator new et operator delete propres à une classe : choix des surcharges alignées

Distinguez la gestion du stockage de la durée de vie de l’objet et transmettez la même valeur d’alignement aux fonctions globales correspondantes.

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

Syntaxe

#include <cstddef>
#include <new>

struct T {
    static void* operator new(std::size_t bytes);
    static void operator delete(void* ptr) noexcept;

    static void* operator new(std::size_t bytes, std::align_val_t alignment);
    static void operator delete(void* ptr, std::align_val_t alignment) noexcept;
};

new T(...) obtient du stockage, puis y initialise un objet. Pour un pointeur valide non nul, delete p, avec la forme non destructrice d’operator delete présentée ici, détruit l’objet avant de libérer son stockage. Un appel direct à operator new n’exécute pas automatiquement de constructeur, et un appel direct à un operator delete non destructeur n’exécute pas automatiquement de destructeur. En revanche, un operator delete destructeur peut appeler le destructeur dans le corps de la fonction, même s’il est appelé directement.

Les fonctions d’allocation et de désallocation propres à une classe sont des fonctions membres statiques, même sans static. Pour un objet unique, la recherche du nom commence normalement dans la classe ; les déclarations qui s’y trouvent masquent les fonctions globales de même nom. Les expressions ::new et ::delete ignorent la recherche dans la classe, mais continuent d’initialiser ou de détruire l’objet. Ne contournez pas une moitié de la paire si l’autre repose sur un mécanisme d’allocation personnalisé. Les tableaux utilisent les formes distinctes new[] et delete[].

Les surcharges avec std::align_val_t, défini dans <new>, existent depuis C++17. En C++23, si alignof(T) dépasse __STDCPP_DEFAULT_NEW_ALIGNMENT__, new tente d’abord de résoudre la surcharge avec un argument d’alignement. En l’absence de correspondance, il réessaie sans cet argument parmi les mêmes déclarations. Au seuil ou en dessous, l’ordre est inversé. Pour les fonctions ordinaires de désallocation, le même seuil détermine la préférence pour une surcharge avec ou sans paramètre d’alignement.

Si la fonction membre appelle ::operator new(bytes, alignment), libérez ce bloc avec ::operator delete(ptr, alignment) en utilisant exactement la même valeur d’alignement. La surcharge sans alignement ne convient pas : enfreindre cette règle entraîne un comportement indéfini. Dans l’exemple, un échec d’allocation lève std::bad_alloc avant l’incrémentation du compteur. Si le constructeur lève une exception après l’allocation, l’expression new appelle une fonction de désallocation adaptée si elle en trouve une, puis propage l’exception.

outstanding compte les blocs alloués par cette paire qui n’ont pas encore été libérés. Il ne compte ni les octets ni les objets vivants, ne garantit pas la sûreté mémoire et ne permet pas de mises à jour concurrentes sûres.

Exemples

#include <cstddef>
#include <cstdio>
#include <new>

struct alignas(64) Tracked final {
    enum class Error { construction_failed };
    static inline std::size_t outstanding = 0;

    explicit Tracked(bool fail) {
        if (fail) {
            throw Error::construction_failed;
        }
    }

    static void* operator new(std::size_t bytes, std::align_val_t alignment) {
        void* ptr = ::operator new(bytes, alignment);
        ++outstanding;
        return ptr;
    }

    static void operator delete(void* ptr, std::align_val_t alignment) noexcept {
        if (ptr != nullptr) {
            ::operator delete(ptr, alignment);
            --outstanding;
        }
    }
};

static_assert(alignof(Tracked) > __STDCPP_DEFAULT_NEW_ALIGNMENT__);

int main() {
    auto* ptr = new Tracked(false);
    std::printf("After new: %zu\n", Tracked::outstanding);
    delete ptr;
    std::printf("After delete: %zu\n", Tracked::outstanding);

    try {
        auto* unexpected = new Tracked(true);
        delete unexpected;
        return 1;
    } catch (Tracked::Error) {
        std::printf("After constructor throws: %zu\n", Tracked::outstanding);
    }
}

Résultat

After new: 1
After delete: 0
After constructor throws: 0

L’exemple exige la prise en charge d’`alignas(64)` et la réussite de l’assertion statique qui vérifie le dépassement du seuil par défaut. Si les deux allocations réussissent, `1` signale un bloc encore alloué ; les deux `0` montrent respectivement la libération par `delete` et celle après une exception du constructeur.

Leçons associées

  • C++ · Leçon 20 · Avancé · Version : 3

Sources