CKTIS / C++
Operatori di allocazione e deallocazione specifici della classe
Una classe può definire le proprie funzioni operator new e operator delete per controllare l’allocazione e il rilascio della memoria. Gli overload che accettano std::align_val_t gestiscono l’allineamento e devono essere compatibili con la funzione di rilascio appropriata.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
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;Le funzioni operator new e operator delete specifiche della classe gestiscono la memoria; non sostituiscono costruttori o distruttori. Sono statiche anche senza static e non possono essere virtuali. Un normale new T cerca prima la funzione di allocazione nella classe; le dichiarazioni trovate possono nascondere gli overload globali. ::new T forza la ricerca globale, mentre ::delete p evita le funzioni di deallocazione specifiche della classe. Non evitarle se ciò comprometterebbe la compatibilità tra allocazione e deallocazione.
Per alignof(T) > __STDCPP_DEFAULT_NEW_ALIGNMENT__, il primo tentativo di selezionare operator new include un argomento std::align_val_t. Se non esiste una funzione corrispondente, la selezione viene ripetuta senza tale argomento; per gli altri tipi l’ordine è inverso. La semplice presenza di un operator new(std::size_t) specifico della classe non garantisce quindi un allineamento maggiore: la sua implementazione deve fornire memoria adatta all’oggetto creato.
Predisponi percorsi di rilascio compatibili: la memoria ottenuta tramite il ::operator new(n, a) globale va rilasciata tramite il ::operator delete(p, a) globale con lo stesso allineamento. Per un normale delete, la preferenza per un overload che accetta std::align_val_t dipende dall’allineamento del tipo. Nell’ambito della classe, dopo aver applicato tale preferenza, prevale l’overload senza std::size_t rispetto a quello che accetta una dimensione. La deallocazione non dovrebbe generare eccezioni.
operator new[] e operator delete[] costituiscono una coppia distinta: gli overload per i singoli oggetti non intercettano gli array. Se l’inizializzazione non riesce, l’espressione new può invocare una funzione di deallocazione appropriata. L’esempio riguarda un solo oggetto; entrambi i percorsi di allocazione delegano all’overload globale con allineamento ed entrambi i percorsi di rilascio al corrispondente.
Identificatori di riferimento trattati in questa voce: Class-specific operator new/delete and matching aligned overloads.
Esempi
#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';
}
Risultato
42 1 1
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.