std::unique_ptr controlla in modo univoco l'oggetto a cui punta e, quindi, non utilizza il conteggio dei riferimenti. Un singleton assicura che un solo oggetto possa essere creato utilizzando il conteggio dei riferimenti.singleton pattern e std :: unique_ptr
Sarebbe quindi std::unique_ptr eseguire identico a un singleton?
Un singleton assicura solo un'istanza di un tipo.
A unique_ptr assicura un solo puntatore intelligente in qualsiasi istanza.
La tua seconda affermazione non è necessariamente vera. –
@PreetKukreti Sono d'accordo con la tua risposta. Potrei essere il mio peggior nemico e affermare che la mia prima affermazione non è necessariamente vera. È possibile sfruttare il codice buggy per duplicare entrambi. Considera che il mio uso di "assicura" significa "prende misure per aiutare a garantire". * Forse dovrei modificare ... * –
no preoccupazioni, ti ho votato comunque, descrivi l'idea generale in modo abbastanza sintetico :) –
Correggimi se ho torto, ma per quanto mi ricordo un singelton è una classe che può avere solo un'istanza. Questo è completamente diverso. Quindi no.
Sarebbe quindi std :: unique_ptr eseguire in modo identico a un singleton?
No. Diciamo che abbiamo classe Foo destinata a essere un singleton. Usando un tipico schema di singleton, non c'è modo di costruire più di un Foo.
Avere un std::unique_ptr<Foo> significa che ci sarà un puntatore a una particolare istanza di Foo, ma ciò non impedisce la creazione di altre istanze di Foo (sia con altri unique_ptr s o con puntatori grezzi a variabili locali). Così Foo, non sarebbe un singleton.
Bella illustrazione, ma penso che tu intendessi 'unique_ptr', non' shared_ptr'? –
Sì, ho digitato male. Grazie per la modifica. –
std::unique_ptr raggiunge la semantica della proprietà singola fornendo solo un costruttore di spostamenti e nessun costruttore di copia o operatore di assegnazione.
Non è affatto un caso di singleton, poiché è possibile avere più unique_ptrs riferimento a istanze diverse dello stesso tipo. Un singleton non ti consente di costruire direttamente il tipo, ma fornisce una funzione di accesso che gestisce una sola istanza.
Inoltre, l'asserzione di Drew che
"A unique_ptr assicura solo un puntatore intelligente a qualsiasi istanza".
è falso. Se semplicemente fare:
T* nt = new T;
std::unique_ptr<T> up1(nt);
std::unique_ptr<T> up2(nt);
allora hai due puntatori uniche che possiedono la stessa risorsa - e si noterà un problema solo in fase di esecuzione, non è tempo di compilazione. Naturalmente, questo è un uso errato di unique_ptr, ma ciò rafforza il fatto che un unique_ptr non garantisce nulla, è semplicemente un contenitore di puntatori che detiene la proprietà esclusiva dalla sua prospettiva e, tramite la sua API, rende difficile creare accidentalmente copie temporanee .
Inoltre, è possibile avere altri tipi di puntatori (intelligenti) che puntano allo stesso puntatore/risorsa raw indipendentemente da qualsiasi unique_ptr. Dipende completamente dal codice di utilizzo per definire le politiche di proprietà e durata delle risorse e le istanze dei puntatori intelligenti
Non capisco come hai raggiunto questa conclusione! –
Beh, ci può essere un numero arbitrario di istanze di un 'std :: unique_ptr' ... –
juanchopanza
@sftrabbit Ho confuso il principio di 'singleton' con quello di' std :: unique_ptr' in qualche modo maciullato.Grazie a tutti per aver fornito chiarimenti. – Mushy