2013-03-11 19 views
12

ho una classe A che ha un campo di tipo std::unique_ptr:Spostare proprietà da std :: shared_ptr a std :: unique_ptr

class A 
{ 
public: 
    std::unique_ptr pointer; 
// class body 
}; 

E da qualche parte nel codice, sto usando pochi std::shared_ptr s che puntano a lo stesso oggetto. Ora quello che mi piacerebbe ottenere è spostare la proprietà su questo std::unique_ptr nella mia classe, in modo che se tutti gli shared_ptr s verranno distrutti, il mio oggetto rimarrà attivo finché questo unique_ptr rimarrà attivo.

La mia domanda è - è possibile spostare la proprietà da std::shared_ptr a std::unique_ptr e se sì, come posso fare questo?

+8

Logicamente, uno scenario del genere non ha senso per me. Supponiamo per un po 'che sia possibile trasferire l'onwership, ma puoi farlo * solo quando * sei sicuro che ci sono solo ** uno ** alvati 'shared_ptr'; se questo è il caso, allora puoi ancora usare 'shared_ptr' come membro di' A' e ** fingere ** che sia 'unique_ptr'. – Nawaz

+1

"sposta la proprietà a questo std :: unique_ptr nella mia classe, in modo che se tutti gli shared_ptrs saranno distrutti, il mio oggetto rimarrà attivo fintanto che questo unique_ptr rimarrà in vita ..." Perché non fare solo un altro condiviso in A? – qPCR4vir

+1

e se ci fossero altri ptr condivisi con lo stesso oggetto? Come potresti gestirlo? 'shared_ptr' non fornisce il metodo' release' per un motivo. –

risposta

14

Logicamente, uno scenario del genere non ha senso per me.

Supponiamo per un istante che è possibile trasferire la proprietà, ma si poteva fare che solo quando sei sicuro che ci sia solo uno shared_ptr alive; se questo è il caso, puoi ancora utilizzare shared_ptr come membro di A e fingere che sia unique_ptr.

E poi commentato:

Questo è vero, ho potuto creare shared_ptr in una classe. Penso di aver frainteso un concetto un po 'di nuovo. Volevo comportarmi in questo modo: se unique_ptr muore, anche l'oggetto stesso muore, anche se shared_ptr s ancora puntano a esso, ma è sciocco perché non saprebbero che l'oggetto stesso è stato distrutto e quindi non sarebbero nullptr S.

In questo caso, stai guardando il puntatore intelligente sbagliato. Quello che probabilmente ti serve è chiamato std::weak_ptr. In tal caso, assicurati di utilizzare uno std::shared_ptr e tutti gli altri come std::weak_ptr.

+3

Beh, in effetti lo scenario mi è apparso legittimo perché il mio codice utilizza 'unique_ptr' (per buoni motivi), ma devo ottenere dati da una lib che non può gestire tipi non copiabili. Certo, voglio sistemare la lib, ma a monte e la distribuzione ci vorrà del tempo, quindi ce l'hai. –