CKTIS / C++
std::unique_ptr — proprietà esclusiva di una risorsa
std::unique_ptr è un puntatore intelligente con proprietà esclusiva che libera automaticamente la propria risorsa. Non può essere copiato, ma la proprietà può essere trasferita a un altro puntatore.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <memory>
std::unique_ptr<T> p = std::make_unique<T>(args...);
std::unique_ptr<T, Deleter> custom;
std::unique_ptr<T[]> array = std::make_unique<T[]>(count);std::unique_ptr<T, D> di <memory> memorizza un puntatore e un deleter. Quando il proprietario viene distrutto, invoca il deleter per un puntatore non nullo: è un’applicazione di RAII. Il deleter predefinito usa delete per un singolo oggetto. Il parametro D permette di personalizzare la liberazione della risorsa.
Usa std::make_unique<T>(args...) per creare un oggetto. La copia di un std::unique_ptr è vietata. L’inizializzazione con auto q = std::move(p); trasferisce la proprietà a q e lascia p vuoto. std::move(p) da solo non trasferisce la risorsa: consente di selezionare un’operazione di spostamento. Prima di dereferenziare un puntatore potenzialmente vuoto, controllalo con if (p).
get() espone il puntatore senza cedere la proprietà. reset() libera la risorsa precedente e lascia vuoto il proprietario; reset(ptr) accetta un puntatore sostitutivo. release() restituisce il puntatore senza liberare la risorsa, quindi il codice chiamante deve occuparsi della sua successiva liberazione. Non creare due proprietari indipendenti dello stesso puntatore grezzo e non eliminare manualmente il risultato di get().
Per gli array, usa std::unique_ptr<T[]>: per impostazione predefinita chiama delete[] e fornisce operator[] invece di operator* e operator->. std::make_unique<T[]>(count) crea un array di questo tipo. Questa voce riguarda C++23; il sito fornito pubblica una bozza in evoluzione, non un testo C++23 congelato. L’opzione del compilatore del repository non certifica l’ambiente di esecuzione di produzione.
Esempi
#include <iostream>
#include <memory>
#include <utility>
int main() {
auto p = std::make_unique<int>(42);
auto q = std::move(p);
std::cout << std::boolalpha;
std::cout << "p owns: " << static_cast<bool>(p) << '\n';
std::cout << "value: " << *q << '\n';
q.reset();
std::cout << "q owns: " << static_cast<bool>(q) << '\n';
}
Risultato
p owns: false value: 42 q owns: false
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.