CKTIS / C++
Selezione degli overload per l’allocazione allineata
Scopri come C++23 seleziona gli overload di classe di `operator new` e `operator delete` e perché le due chiamate globali devono ricevere lo stesso valore di allineamento.
Versione: ISO C++23; implementation support may vary
Sintassi
// 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{} ottiene memoria e vi inizializza un oggetto di tipo T. Nel caso mostrato, delete p distrugge l’oggetto e poi ne libera la memoria. Le chiamate dirette a operator new e operator delete gestiscono memoria grezza: non chiamano né il costruttore né il distruttore di T.
In C++23, new T{} cerca operator new prima nella classe. Le dichiarazioni trovate nella classe nascondono gli overload globali; ::new T{} salta l’ambito della classe. Se alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, il primo tentativo di risoluzione passa alignof(T) come std::align_val_t dopo la dimensione. Se nessuna funzione corrisponde, si ritenta senza l’allineamento. Per gli altri tipi l’ordine è inverso. Anche un overload di classe senza parametro di allineamento deve restituire memoria allineata correttamente.
Per il tipo mostrato, delete p cerca operator delete nella classe e passa all’ambito globale se non vi trova dichiarazioni. La funzione di deallocazione viene scelta indipendentemente da quella di allocazione: sopra la stessa soglia si preferisce una forma con std::align_val_t, altrimenti una senza. Se il costruttore lancia un’eccezione dopo che l’allocazione è riuscita, l’espressione new chiama una funzione di deallocazione adatta, se la trova; poi l’eccezione continua a propagarsi.
Passa il puntatore restituito da ::operator new(bytes, alignment) a ::operator delete(p, alignment) con esattamente lo stesso valore di allineamento. Usare l’overload senza allineamento o un valore diverso causa un comportamento indefinito. Anche ::delete p è un’espressione che distrugge l’oggetto, ma salta la deallocazione specifica della classe e quindi qui non sostituisce delete p.
L’esempio riguarda un solo oggetto; per gli array si abbinano new[] e delete[]. outstanding conta le allocazioni riuscite attraverso questa classe che non sono ancora state liberate, non i byte né gli oggetti ancora in vita. Il ritorno a zero non dimostra che la gestione della memoria sia sicura.
Esempi
#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';
}Risultato
0 1 0
Se l’allocazione riesce, le righe attese sono `0`, `1`, `0`. La piattaforma di destinazione deve supportare `alignas(64)` e soddisfare la condizione di `static_assert`; il supporto dipende dall’implementazione.
Lezioni correlate
- C++ · Lezione 20 · Avanzato · Versione: 3