In pratica non è possibile restituire unique_ptr per il puntatore come la semantica della proprietà?

Question

Ho scritto un metodo factory statico che restituisce un nuovo oggetto Foobar popolato da un altro oggetto dati. Recentemente sono stato ossessionato dalla semantica della proprietà e mi sto chiedendo se sto trasmettendo il messaggio giusto facendo in modo che questo metodo di fabbrica restituisca un unique_ptr.

class Foobar { 
public: 
    static unique_ptr<Foobar> factory(DataObject data); 
} 

Il mio intento è di dire al codice client di essere il proprietario del puntatore. Senza un puntatore intelligente, vorrei semplicemente restituire Foobar*. Vorrei, tuttavia, far rispettare questa memoria per evitare potenziali bug, quindi unique_ptr sembrava una soluzione appropriata. Se il cliente desidera estendere la durata del puntatore, chiama semplicemente .release() una volta ottenuto il numero unique_ptr.

Foobar* myFoo = Foobar::factory(data).release(); 

La mia domanda è disponibile in due parti:

1. Questo approccio trasmettere la semantica di proprietà corrette?
2. È una "cattiva pratica" restituire unique_ptr anziché un puntatore non elaborato?

Answer 1

Il ripristino di un std::unique_ptr da un metodo di fabbrica è perfetto e dovrebbe essere una pratica consigliata. Il messaggio che trasmette è (IMO): Ora sei l'unico proprietario di questo oggetto. Inoltre, per tua comodità, l'oggetto sa come distruggere se stesso.

Penso che sia molto meglio restituire un puntatore non elaborato (in cui il client deve ricordare come e se eliminare questo puntatore).

Tuttavia, non capisco il tuo commento sul rilascio del puntatore per estendere la sua durata. In generale raramente vedo una ragione per chiamare release su uno smartpointer, poiché penso che i puntatori debbano essere sempre gestiti da una sorta di struttura RAII (solo l'unica situazione in cui chiamo release consiste nel mettere il puntatore in una diversa struttura di gestione, ad es. un unique_ptr con un deleter diverso, dopo che ho fatto qualcosa per garantire una pulizia aggiuntiva).

Pertanto il cliente può (e dovrebbe) semplicemente memorizzare il unique_ptr da qualche parte (ad esempio un altro unique_ptr, che è stata mossa costruito da quello restituito) fintanto che hanno bisogno l'oggetto (o un shared_ptr, se hanno bisogno di più copie del puntatore).Quindi il codice lato client dovrebbe essere più simile a questo:

std::unique_ptr<FooBar> myFoo = Foobar::factory(data); 
//or: 
std::shared_ptr<FooBar> myFoo = Foobar::factory(data); 

Personalmente vorrei anche aggiungere una typedef per il tipo di puntatore restituito (in questo caso std::unique_ptr<Foobar>) ed o il deleter utilizzato (in questo caso std :: default_deleter) a il tuo oggetto di fabbrica. Ciò rende più facile se in seguito si decide di modificare l'allocazione del puntatore (e quindi è necessario un metodo diverso per la distruzione del puntatore, che sarà visibile come un secondo parametro del modello di std::unique_ptr). quindi vorrei fare qualcosa di simile:

class Foobar { 
public: 
    typedef std::default_deleter<Foobar>  deleter; 
    typedef std::unique_ptr<Foobar, deleter> unique_ptr; 

    static unique_ptr factory(DataObject data); 
} 

Foobar::unique_ptr myFoo = Foobar::factory(data); 
//or: 
std::shared_ptr<Foobar> myFoo = Foobar::factory(data); 

Answer 2

A std::unique_ptr possiede univocamente l'oggetto a cui punta. Dice "Posseggo questo oggetto, e nessun altro lo fa".

Questo è esattamente ciò che stai cercando di esprimere: stai dicendo "chiamante di questa funzione: ora sei l'unico proprietario di questo oggetto, fallo come ti pare, la sua vita è una tua responsabilità".

Answer 3

Esso trasmette esattamente la semantica corretta ed è il modo in cui penso che tutte le fabbriche in C++ dovrebbero funzionare: std::unique_ptr<T> non impone alcun tipo di semantica della proprietà ed è estremamente economico.