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.