Convenzione di nomi per l'eliminazione dei dati in C++

Question

Si supponga di disporre di un metodo C++ che restituisce un puntatore a un oggetto. Qualcosa nel file di intestazione che assomiglia a questo:

uint8_t* getData(void); 

Questo ragazzo restituisce un array di byte, ma non c'è nulla che dice che se questo è un pezzo dinamico o generato staticamente dei dati (locale alla classe o creati con il nuovo).

Esiste una convenzione di denominazione specifica in C++ per distinguere tra metodi che restituiscono memoria allocata dinamicamente (e quindi deve essere cancellata dal richiedente), vs metodi che restituiscono semplicemente un riferimento a una porzione di dati definita staticamente?

Qual è il modo preferito per farlo o dipende dalla situazione?

Answer 1

mie convenzioni sono:

uint8_t* getData(); 

è assegnato staticamente, o almeno non è la mia responsabilità per l'eliminazione di questi dati. Tuttavia, se si tratta di un array, scriverei:

pair<uint8_t*,uint8_t*> getData(); 

Oppure definire un contenitore per quello.

auto_ptr<uint8_t> getData(); 
unique_ptr<uint8_t> getData(); 

alloca singolo oggetto e ora lo possiedo.

shared_ptr<uint8_t> getData(); 

alloca singolo oggetto con proprietà condivisa.

vector<uint8_t> getData(); 

alloca una matrice, vettore possiede la memoria.

Answer 2

In C++, in primo luogo non distribuite semplicemente i puntatori grezzi ai client. Una possibile soluzione:

std::vector<uint8_t> getData(); 

Answer 3

Inserire nella documentazione.

Answer 4

MODIFICATO!
Se si restituisce il puntatore a una matrice allocata localmente, il programma si bloccherà quando si tenta di utilizzare questo puntatore, poiché dopo essere usciti dalla funzione, la matrice verrà distrutta. In realtà, un crash sarà il comportamento migliore, perché questa situazione è un comportamento indefinito. Ecco perché - restituisci un indirizzo di qualcosa che non esiste più. Quindi, il miglior pensiero che potrebbe accadere è un crash (dopo aver provato ad usarlo comunque). L'altra opzione è che questo indirizzo sia un indirizzo di un altro oggetto nel tuo programma (non sai quale), quindi se provi a modificarlo, è davvero una brutta cosa.
L'altra variante - restituire il puntatore all'array, assegnata con "new" è molto pericolosa ed è una potenziale perdita di memoria . Quindi, usa i puntatori intelligenti: è il modo migliore (/ * vedi il commento di Roger Pate a questa domanda sull'uso di puntatori intelligenti */
L'altro modo è di restituire una copia dell'array (usando std :: vector), ma è molto lento (se la matrice è grande, specialmente quando la matrice è di un grande tipo definito dall'utente), e nella maggior parte dei casi non è una buona idea.

// Grazie a ybungalobill, Steve e Roger Patè per i loro commenti!

Answer 5

Infatti, è molto raro che si desideri effettivamente restituire un puntatore alla memoria allocata in modo non dinamico. Non credo che causerà un arresto anomalo del programma, una volta che ho scritto una libreria di threading che utilizzava dichiarazioni di array per gonfiare lo stack di runtime e lo spazio di archiviazione per i thread; il fatto che la memoria che sta indicando possa cambiare a caso è ciò che è pericoloso.

Answer 6

Uno cannot return static data pointer o di variabile locale dal momento che lo stack disattiva gli oggetti distrutti. Deve essere assegnato dinamicamente ed è sempre il callers responsibility to free poiché la funzione non sa quando liberarlo.

Inoltre, si prega di tenere presente che molte funzioni richiedono speciali deallocaters e fare delete o delete [] non è sempre l'opzione giusta. Potresti finire per corrompere il mucchio! Leggi la documentazione della funzione per tali informazioni.

Answer 7

Se è responsabilità del client gestire la memoria restituita, è necessario utilizzare una qualche classe di wrapping che gestisca questa responsabilità. Quando si usa un array, si dovrebbe quasi sempre restituire un vettore std, perché questo gestirà anche gli aspetti dell'array come la dimensione, il ridimensionamento, ecc, ma per un puntatore non elaborato si dovrebbe usare tipicamente std :: auto_ptr o std :: shared_ptr. Se stai scrivendo un modulo destinato a essere usato tra i compilatori, scrivi il tuo. È facile restituire un oggetto proxy che può essere convertito in varie marche di puntatore intelligente.

Answer 8

Se le funzioni restituiscono puntatori, quindi utilizzare getData per ottenere l'accesso alla memoria senza assumerne la proprietà e adoptData per l'accesso e la proprietà. Almeno questa è la convenzione che ho visto usato più spesso.

Ma come altri hanno già detto, restituire un contenitore, un puntatore intelligente o qualcos'altro che gestirà automaticamente la memoria. RAII è tuo amico.

E non dimenticare di indicare nei documenti API di entrambe le funzioni se trasferiscono la proprietà o meno. La convention è eccezionale per le persone che lo conoscono, ma deve comunque essere conveniente per coloro che non lo conoscono.

Answer 9

In Clang v'è una semplice convenzione (controllarlo fuori here):

• getX restituisce un puntatore, non la proprietà
• takeX rendimenti sia puntatore e la proprietà

Tuttavia, come è stato notato, vorrei sollevare le abilità del compilatore qui e restituire un gestore intelligente (puntatore intelligente, contenitore, qualunque) piuttosto che un puntatore nudo quando si restituisce la proprietà.

E 'troppo facile lasciare uno slittamento perdita di memoria in cui tutto ciò che dovete aiutare è una convenzione di denominazione ... si può ancora mantenere la convenzione di denominazione però;)

Answer 10

come molti hanno detto, non restituisce un puntatore non elaborato. Se si desidera che i dati vengano eliminati dal richiedente (per qualche motivo), è possibile utilizzare qualcosa come shared_ptr o auto_ptr, nel qual caso il chiamante pulisce il valore restituito (tempo che desidera o no). Se invece si restituisce un membro di una classe che non viene ripulita, allora non si restituisce affatto un puntatore, si restituisce un riferimento (possibilmente const).