CKTIS / C++
new — creare oggetti e ottenere memoria
Un’espressione new crea un oggetto e restituisce un puntatore a esso; di solito ottiene anche memoria. Distinguila dalla funzione di allocazione operator new e scopri new[] per gli array e l’espressione Placement new, che costruisce un oggetto nella memoria fornita.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
new T(args...)
new T{args...}
new T[n]{}
::new (address) T{args...}
new (std::nothrow) T{args...}Se T non è un tipo array, new T{args...} crea e inizializza un oggetto e restituisce un puntatore di tipo T*. Un’espressione new non è la stessa cosa della funzione operator new: quest’ultima fornisce memoria grezza, ma non chiama direttamente un costruttore. L’inizializzatore è importante: new int lascia un valore indeterminato che non deve essere letto in C++23; new int{} produce zero.
La forma per array new[], ad esempio new T[n]{}, crea un array. Se l’operazione riesce e n > 0, restituisce un puntatore al primo elemento. In C++23 n == 0 è ammesso: l’array non contiene elementi, quindi il puntatore restituito non deve essere dereferenziato. Abbina delete al normale new per un singolo oggetto e delete[] al new che crea un array, anche se di lunghezza zero. Per esempio, dopo using T = int[3];, new T{} restituisce un puntatore di tipo int* al primo elemento. Per eliminare l’array devi usare delete[], anche se l’espressione new non contiene parentesi quadre. Mescolare queste forme causa comportamento indefinito. L’eliminazione degli oggetti non azzera i puntatori che contengono i loro indirizzi.
La funzione standard di allocazione con eccezioni genera std::bad_alloc quando non riesce a ottenere memoria. Se new (std::nothrow) T{} seleziona l’overload standard della funzione di allocazione che non genera eccezioni, l’espressione restituisce nullptr se l’allocazione fallisce. Se T è un tipo classe, l’espressione può invece selezionare un overload di allocazione specifico della classe che accetta std::nothrow_t ma può comunque generare un’eccezione. Anche con l’overload standard che non genera eccezioni, l’espressione può propagare un’eccezione del costruttore. Controlla il risultato prima di dereferenziarlo. Se un costruttore genera un’eccezione, l’espressione new chiama una funzione di deallocazione appropriata, se ne trova una.
Un’espressione Placement new nella forma ::new (address) T{args...}, che usa l’overload standard con void* di <new>, costruisce un oggetto nella memoria esistente senza allocarla. L’indirizzo fornito non deve essere nullptr e la memoria deve essere abbastanza grande, correttamente allineata e disponibile per tutta la durata dell’oggetto. Per il buffer dell’esempio, chiama placed->~Item(), non delete placed; il buffer ha una propria durata.
Ambito della voce: C++23. Il flag del compilatore associato nel repository non attesta l’ambiente di produzione. L’URL dello standard fornito rimanda a una bozza di lavoro in evoluzione, non a un’edizione C++23 congelata.
Esempi
#include <cstddef>
#include <iostream>
#include <new>
struct Item {
int value;
};
int main() {
int* single = new int{7};
std::cout << *single << '\n';
delete single;
int* array = new int[3]{1, 2, 3};
std::cout << array[0] + array[1] + array[2] << '\n';
delete[] array;
alignas(Item) std::byte storage[sizeof(Item)];
Item* placed = ::new (static_cast<void*>(storage)) Item{9};
std::cout << placed->value << '\n';
placed->~Item();
}
Risultato
7 6 9
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.