Un distruttore - dovrei usare cancellare o cancellare []?

Question

Sto scrivendo una classe template che accetta come input un puntatore e lo memorizza. Il puntatore è destinato a puntare a un oggetto assegnato da un'altra classe e consegnato alla classe contenente questo.

Ora voglio creare un distruttore per questo contenitore. Come posso liberare la memoria puntata da questo puntatore? Non ho modo di sapere a priori se si tratta di un array o di un singolo elemento.

Sono una specie di nuovo in C++, quindi portami con me. Ho sempre usato C e Java è il mio linguaggio OO di scelta, ma tra il voler imparare il C++ e i requisiti di velocità del mio progetto, sono andato con il C++.

Sarebbe una buona idea cambiare il contenitore da un modello a un contenitore per una classe astratta in grado di implementare il proprio distruttore?

Answer 1

Se non si sa se è stato assegnato con new o new[], non è sicuro cancellarlo.

Il tuo codice potrebbe sembrare funzionare. Ad esempio, su una piattaforma su cui lavoro, la differenza è importante solo quando si dispone di una matrice di oggetti con distruttori. Quindi, si esegue questa operazione:

// by luck, this works on my preferred platform 
// don't do this - just an example of why your code seems to work 
int *ints = new int[20]; 
delete ints; 

ma poi si esegue questa operazione:

// crashes on my platform 
std::string *strings = new std::string[10]; 
delete strings; 

Answer 2

Risposta breve:

Se si utilizza [] con il nuovo che si desidera utilizzare [] con eliminazione.

//allocate some memory 
myObject* m = new myObject[100]; 

//later on...destructor... 
delete m; //wrong 
delete[] m; //correct 

Quello era nudo le ossa, l'altra cosa che si poteva guardare è boost. Anche abbastanza difficile rispondere considerando che non sei sicuro se sia un array o un singolo oggetto. Puoi controllare questo tramite una bandierina che dice alla tua app se usare cancella o cancella [].

Answer 3

Un puntatore intelligente come spinta shared_pointer già ha questa coperta, potrebbe usarlo? linky

Answer 4

Come regola generale di sviluppo, si dovrebbero usare per un progetto in cui la classe che chiama new dovrebbe anche chiamare delete

Answer 5

Devi documentare come questa classe si aspetta di essere utilizzato, e allocare sempre come previsto. Puoi anche passare un flag all'oggetto specificando come dovrebbe distruggere. Dai un'occhiata anche allo smart pointers di boost, che può gestire questa distinzione per te.

Answer 6

Non dovresti eliminarlo affatto. Se la tua classe prende un puntatore già inizializzato, non è sicuro cancellarlo. Potrebbe non puntare nemmeno a un oggetto sull'heap; chiamare delete o delete[] potrebbe essere disastroso.

L'allocazione e la deallocazione della memoria devono avvenire nello stesso ambito. Quale mai il codice possiede e inizializza l'istanza della tua classe è anche presumibilmente responsabile per l'inizializzazione e il passaggio del puntatore, e che è dove dovrebbe essere il tuo delete.

Answer 7

Poiché il puntatore in C++ non ci dice come è stato assegnato, sì, non c'è modo di decidere quale metodo di deallocazione utilizzare.La soluzione è dare la scelta all'utente che si spera sappia come è stata allocata la memoria. Dai un'occhiata alla libreria Boost smart ptr, in particolare al costruttore shared_ptr con il secondo parametro, per un ottimo esempio.

Answer 8

• Utilizzare delete se assegnato con new.
• Utilizzare delete[] se assegnato con new[].

Dopo queste affermazioni, se avete ancora un problema (forse si vuole eliminare un oggetto che è stato creato da qualcun altro), allora si sta rompendo la terza regola:

• cancellare sempre quello che si creato. Corollario, non eliminare mai ciò che non hai creato.

Answer 9

(Moving mio commento in una risposta, a richiesta.)

risposta di Jonh ha ragione (sull'uso di distruzione di matrice solo quando si è utilizzato la costruzione array), quindi forse si dovrebbe offrire modelli: uno per array, uno no.

L'altra risposta è di evitare gli array e invece si aspettano una singola istanza che può o meno essere una raccolta corretta che ripulisce dopo se stessa, come ad esempio il vettore <>.

modificare

Rubare palesemente da Roger Pate, aggiungerò che si potrebbe richiedere l'uso di un puntatore intelligente, il che equivale a una raccolta singolo elemento.

Answer 10

In parole povere, dato solo un puntatore alla memoria allocata dinamicamente non c'è modo di determinare come de-allocarlo in modo sicuro. Il puntatore avrebbe potuto essere allocata in una delle seguenti modalità:

• usando nuovo
• utilizzando nuovo []
• usando malloc
• utilizzando una funzione definita dall'utente
• ecc

In tutti i casi prima di poter deallocare la memoria è necessario sapere come è stata allocata.

Answer 11

Se si dispone di una classe che accetta un puntatore, ne assume la proprietà, quindi il contratto per l'utilizzo della classe deve includere uno di un paio di elementi. O:

• l'interfaccia deve indicare in che modo è stato allocato l'oggetto puntato dal puntatore in modo che il nuovo proprietario possa sapere come rilasciare l'oggetto in modo sicuro. Questa opzione ha il vantaggio di mantenere le cose semplici (a un livello comunque), ma non è flessibile - la classe non può gestire l'assunzione di proprietà di oggetti statici e oggetti allocati dinamicamente.

o

• l'interfaccia deve includere un meccanismo in cui una politica deallocazione può essere specificato da tutto ciò che è dando il puntatore alla classe. Questo può essere semplice quanto fornire un meccanismo per passare in un funtore (o anche un semplice puntatore a funzione vecchia) che verrà chiamato per deallocare l'oggetto (preferibilmente nella stessa funzione/costruttore che passa nel puntatore stesso). Questo rende la classe discutibilmente più complicata da usare (ma avere una politica di default per chiamare delete sul puntatore, ad esempio, potrebbe renderlo facile da usare come l'opzione 1 per la maggior parte degli usi). Ora se qualcuno vuole dare alla classe un puntatore a un oggetto assegnato staticamente, può passare in un functor no-op quindi nulla accade quando la classe vuole deallocarlo o un functor a un'operazione delete[] se l'oggetto è stato assegnato da new[] , ecc.