Passaggio di unique_ptr alle funzioni

Question

Sto provando a "modernizzare" un codice esistente.

• Ho una classe che attualmente ha una variabile membro "Dispositivo * dispositivo_".
• Si utilizza nuovo per creare un'istanza in un codice di inizializzazione e ha un "delete device_" nel distruttivo.
• Funzioni membro di questa classe chiamata molte altre funzioni che richiedono un dispositivo * come parametro.

Questo funziona bene, ma per "modernizzare" il mio codice ho pensato che dovrebbe modificare la variabile per essere definito "std::unique_ptr<Device> device_" e rimuovere la chiamata esplicita di cancellare, il che rende il codice più sicuro e generalmente migliore.

La mia domanda è questa -

• Come devo quindi far passare il dispositivo _ variabile per tutte le funzioni che ne hanno bisogno come paramater?

Posso chiamare .get per ottenere il puntatore raw in ogni chiamata di funzione. Ma sembra brutto e spreca alcuni dei motivi per utilizzare un unique_ptr in primo luogo.

O posso cambiare ogni funzione in modo che invece di prendere un parametro di tipo "Device *" ora vuole un paramater di tipo "std :: unique_ptr &". Quale (per me) offusca in qualche modo i prototipi di funzione e li rende difficili da leggere.

Qual è la migliore pratica per questo? Ho perso altre opzioni?

Answer 1

In moderna C stile ++, ci sono due chiavi concetti:

• Proprietà
• Nullità

proprietà è sul proprietario di un oggetto/risorsa (in questo caso , un'istanza di Device). I vari std::unique_ptr, boost::scoped_ptr o std::shared_ptr riguardano la proprietà.

Nullity è molto più semplice tuttavia: esprime solo se un dato oggetto potrebbe essere nullo e non si preoccupa di nient'altro, e certamente non di proprietà!

---

Si erano destra per spostare l'implementazione della classe verso unique_ptr (in generale), anche se si consiglia un puntatore intelligente con la semantica profonda di copia, se il vostro obiettivo è quello di attuare un Pimpl.

Ciò dimostra chiaramente che la tua classe è l'unica responsabile di questo pezzo di memoria e si occupa in modo ordinato di tutti i vari modi in cui la memoria potrebbe aver perso il contrario.

---

D'altra parte, la maggior parte degli utenti delle risorse non potrebbe interessare di meno la sua proprietà.

Fintanto che una funzione non mantiene un riferimento a un oggetto (memorizzarlo in una mappa o qualcosa del genere), tutto ciò che conta è che la durata dell'oggetto supera la durata della chiamata di funzione.

Quindi, scegliere come passare il parametro dipende dalla sua possibile Nullità:

• mai nulla? Passa un riferimento
• Forse null?Passare un puntatore , un semplice puntatore nudo o una classe puntatore-simile (con una trappola sul nulla, per esempio)

---

Answer 2

Vorrei utilizzare std::unique_ptr const&. L'uso di un riferimento non const darà alla funzione chiamata la possibilità di reimpostare il puntatore.
Penso che questo sia un buon modo per esprimere che la funzione chiamata può usare il puntatore ma nient'altro.
Quindi per me questo renderà l'interfaccia più facile da leggere. So che non devo giocherellare con il puntatore passato a me.

Answer 3

Questo potrebbe non essere fattibile per voi, ma sostituire ogni occorrenza di Device* per const unique_ptr<Device>& è un buon inizio.

Ovviamente non è possibile copiare unique_ptr s e non si desidera spostarlo. La sostituzione con un riferimento a unique_ptr consente al corpo dei corpi delle funzioni esistenti di continuare a funzionare.

Ora c'è una trappola, è necessario passare const & per evitare che i callees eseguano unique_ptr.reset() o unique_ptr().release(). Si noti che questo ancora passa un puntatore modificabile al dispositivo. Con questa soluzione non è semplice passare un puntatore o un riferimento a const Device.

Answer 4

Dipende davvero. Se una funzione deve assumere la proprietà di unique_ptr, la sua firma deve assumere un valore unique_ptr<Device> bv e il chiamante deve utilizzare il puntatore std::move. Se la proprietà non è un problema, manterrò la firma del puntatore raw e passerò il pointer unique_ptr usando get(). Questo non è brutto se la funzione in questione non assume la proprietà.

Answer 5

La procedura consigliata probabilmente non è quella di utilizzare std::unique_ptr in questo caso, sebbene dipenda. (In genere non si dovrebbe avere più di un puntatore non elaborato su un oggetto allocato dinamicamente in una classe, sebbene dipenda anche da questo . L'unica cosa che non si vuole fare in questo caso è passando intorno a (e come hai notato, std::unique_ptr<> const& è un po 'ingombrante e offuscante). Se questo è l'unico puntatore assegnato in modo dinamico nell'oggetto, inserisco semplicemente con il puntatore raw e il delete nel distruttore. Se ci sono diversi indicatori di questo tipo, prenderei in considerazione il relegare ciascuno di essi in una classe base separata (dove possono ancora essere puntatori raw).