CKTIS / C++
Sélection des surcharges pour l’allocation alignée
Comprendre comment C++23 sélectionne les surcharges de classe de `operator new` et `operator delete`, et pourquoi les deux appels globaux doivent recevoir le même alignement.
Version : ISO C++23; implementation support may vary
Syntaxe
// 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);new T{} obtient de la mémoire et y initialise un objet de type T. Dans le cas présenté, delete p détruit l’objet puis libère sa mémoire. Les appels directs à operator new et à operator delete gèrent de la mémoire brute : ils n’appellent ni le constructeur ni le destructeur de T.
En C++23, new T{} recherche d’abord operator new dans la classe. Les déclarations qui s’y trouvent masquent les surcharges globales ; ::new T{} ignore la portée de la classe. Si alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, la première tentative de résolution passe alignof(T) sous la forme d’un std::align_val_t après la taille. Si aucune fonction ne correspond, la seconde tentative omet l’alignement. Pour les autres types, l’ordre est inversé. Même sans paramètre d’alignement, une surcharge de classe doit fournir une mémoire correctement alignée.
Pour le type présenté, delete p recherche operator delete dans la classe, puis dans la portée globale s’il n’y trouve aucune déclaration. Le choix de la fonction de désallocation est indépendant de celui de la fonction d’allocation : au-dessus du même seuil, la forme avec std::align_val_t est préférée ; sinon, c’est celle sans ce paramètre. Si le constructeur lève une exception après une allocation réussie, l’expression new appelle une fonction de désallocation appropriée si elle en trouve une, puis l’exception continue de se propager.
Passez le pointeur renvoyé par ::operator new(bytes, alignment) à ::operator delete(p, alignment) avec exactement la même valeur d’alignement. Employer la surcharge sans alignement ou une valeur différente entraîne un comportement indéfini. ::delete p reste une expression qui détruit l’objet, mais contourne la désallocation propre à la classe : elle ne remplace donc pas delete p ici.
L’exemple porte sur un seul objet ; pour les tableaux, on associe new[] à delete[]. outstanding compte les allocations réussies via cette classe dont la mémoire n’a pas encore été libérée, et non des octets ou des objets encore en vie. Un retour à zéro ne prouve pas la sûreté de la gestion mémoire.
Exemples
#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';
}Résultat
0 1 0
Si l’allocation réussit, les lignes attendues sont `0`, `1`, `0`. La cible doit prendre en charge `alignas(64)` et satisfaire la condition de `static_assert` ; la prise en charge dépend de l’implémentation.
Leçons associées
- C++ · Leçon 20 · Avancé · Version : 3