Dovrebbe essere chiamato "delete this" da un metodo membro?

Question

Stavo leggendo questo article e voleva così la gente consiglio:

D: Dovrebbe delete this; essere chiamata dall'interno di un metodo di membro?

Answer 1

Normalmente questa è una cattiva idea, ma a volte è utile.

È perfettamente sicuro fino a quando non si utilizzano variabili membro dopo aver eliminato e finché i client che chiamano questo metodo capiscono che potrebbe eliminare l'oggetto.

Un buon esempio di quando questo è utile è se la classe utilizza il conteggio dei riferimenti:

void Ref() { 
    m_References++; 
} 

void Deref() { 
    m_References--; 
    if (m_References == 0) { 
    delete this; 
    } 
} 

Answer 2

Non senza una buona ragione per farlo.

Il problema è che quando si chiama delete this in una funzione membro, si sta creando un brutto effetto collaterale: il chiamante ha ancora un riferimento all'istanza che ora è completamente non valida.

Questo probabilmente non è un comportamento previsto, quindi potrebbe facilmente portare a bug sgradevoli.

Detto questo, ci sono momenti in cui questo è appropriato (ho visto alcuni schemi di gestione della memoria, con determinate librerie, in cui si creano esplicitamente metodi nelle classi che si cancellano - principalmente per l'interoperabilità linguistica). In generale, penso che sia una cattiva pratica, però.

Answer 3

Penso che ci sono davvero 2 domande qui

possibile eliminare questo essere chiamato validamente da un metodo membro ?

Sì. Questo è legale finché si è molto attenti con l'uso.

L'eliminazione deve essere utilizzata all'interno di un metodo membro?

In casi molto specifici questo è necessario. Alcuni tipi di puntatori intelligenti, ad esempio, utilizzano il modello delete this per eliminare il puntatore. Esempi: stile CComPtr<>.

Oltre ai puntatori intelligenti, dovrebbe essere evitato a meno che non si abbia una buona ragione per farlo. Anche allora, vorrei riconsiderare attentamente il mio scenario e vedere se c'era un modo per aggirarlo.

Answer 4

Sì, ci sono alcuni casi in cui è comune.

conteggio Riferimento:

void release() 
{ 
    cnt--; 
    if (cnt == 0) 
    delete this; 
} 

programmazione GUI. In alcuni framework, quando un utente chiude una finestra, è normale che la finestra si elimini.

Answer 5

Sì, è possibile e here's una buona spiegazione di quando e perché

Answer 6

Si può fare, a condizione propria l'ultimo elemento in una funzione membro, e che dopo il ritorno si dimenticano che oggetto mai esistito .... ma si, come l'articolo chiede ... Perché vorresti farlo?Non so cosa dice lo standard, ma mi dà una sensazione strana: P

Immagino che questo è un po 'come se dovessi usare una dichiarazione GOTO, e io personalmente uso GOTO per ripulire le risorse in C a volte, specialmente in condizioni eccezionali.

mi chiedo quali sono le implicazioni stato condiviso sono (dichiarazione sfocata lo so): P

Answer 7

Alcune librerie di threading usano in sede di attuazione un auto distruggere al termine thread.

void Thread::threadFunc() 
{ 
    doRun(); 

    if(this->destroyOnExit == true) 
     delete this; 
} 

Answer 8

Questo è stato spesso utilizzato nei giorni MFC. IIRC l'ultimo messaggio di una finestra riceve è WM_NCDESTROY, a quel punto si potrebbe chiamare delete this, supponendo che tu fossi una qualche forma di sadico naturalmente (anche se MFC stesso ha fatto questo a volte penso.)

Answer 9

Tutto pronto per i voti verso il basso.

dovrebbe: No.
Can tecnicamente: Sì
E 'una buona idea: Assolutamente no.
Ci sono situazioni che è utile: Naturalmente. Se sei C++ foo è estremamente forte. Ma la maggior parte delle persone non è così brava. Quindi fallo solo se hai un team di persone che lavorano con te in grado di fare una revisione decente del codice.

Perché:
Non c'è modo per un oggetto di sapere che è stato allocata dinamicamente (e deve quindi eliminare) o è un oggetto normale (e quindi non deve essere cancellato) e, quindi, come può esso decidide tempo dovrebbe essere cancellato. Quindi se un oggetto si sta cancellando, a mio parere c'è qualcosa di terribilmente sbagliato nel design.

Se si dispone di un oggetto che deve essere gestito, è necessario scrivere un oggetto seprate per la gestione (quindi indicatori intelligenti). Lascia che l'oggetto faccia ciò che è buono, quindi separi la gestione dell'oggetto in un altro oggetto.

Answer 10

Sì. Come tutte le risposte dicono, se sei sicuro al 100% che i dati della classe non saranno utilizzati dopo che è stato chiamato lo delete this.

Ad esempio, in un progetto:

void Test() 
MyClass * Someclass = new MyClass; 
SomeClass->DoYourThing(); 
SomeClass->KillYourself(); 
return; 

void MyClass::DoYourThing() { return; } 
void MyClass::KillYourself() {delete this;} 

spiegazione molto semplice, il progetto utilizzato delete this; nell'ambito della gestione della memoria per oggetti di quel tipo; il loro costruttore li ha aggiunti ad una lista privata di classi di quel tipo in uso, e si sono tolti da quella lista quando sono stati distrutti e poi cancellati (questo non era in un distruttore). Tutti gli oggetti di quella classe che non si erano eliminati quando il programma ha raggiunto il suo endpoint poi tutti avevano il loro equivalente KillYourself() chiamato da una funzione di membro static CleanYourselves()

Answer 11

1. delete this non può essere chiamato da una funzione non membro :)
2. È una cattiva idea farlo finché non capisci le sue conseguenze.

Answer 12

Anche se non direttamente correlato a questo thread, volevo chiarirlo. mi è stato chiesto una domanda che, data una situazione:

int* a = new int ; 
int* b = a ; 
delete a; 

Ora è la dichiarazione successiva al sicuro?

cout<<*b ;

La mia risposta: Dopo eliminare una, la posizione indicata dal un è stato contrassegnato per l'eliminazione e in qualsiasi punto del tempo che può essere assegnato a qualche altro oggetto. Quindi l'accesso al valore utilizzando b non è sicuro in quanto potrebbe essere modificato dopo essere stato assegnato a un altro oggetto.

Nota: No downvoting per favore, questo è solo un chiarimento