Cosa succede durante l'istruzione `delete this;`?

Question

perche il seguente codice:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this;} 
private: 
    int x; 
}; 

Quello che sta accadendo (ed è valido?) Nei seguenti due opzioni:

opzione 1:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
    delete a; 
} 

Opzione 2:

void main() 
{ 
    foo a; 
    a.done(); 
} 

Sarà la seconda dichiarazione delete a; a opt ion 1 causerà un'eccezione o un danneggiamento dell'heap?

L'opzione 2 causerà un'eccezione o un danneggiamento dell'heap?

Answer 1

delete this; è consentito, elimina l'oggetto.

Entrambi i frammenti di codice hanno un comportamento non definito - nel primo caso l'eliminazione di un oggetto che è già stato eliminato e nel secondo caso l'eliminazione di un oggetto con durata di archiviazione automatica.

Poiché il comportamento non è definito, lo standard non indica se causerà un'eccezione o un danneggiamento dell'heap. Per diverse implementazioni potrebbe essere né, né, né entrambi, e potrebbe o meno essere uguale ogni volta che si esegue il codice.

Answer 2

Entrambi causerebbero un errore.

Il primo puntatore viene eliminato due volte, con la seconda delete causa l'errore mentre il secondo è allocato sullo stack e non può essere soppresso implicitamente (errore causato dalla prima chiamata del distruttore).

Answer 3

Entrambi avrebbero causare un errore, ciò che si vuole è:

void main() 
{ 
    foo* a = new foo(); 
    a->done(); 
} 

cui il compilatore si espanderà a qualcosa di simile al di sotto, che spero marche eliminazione di "questo" un po 'meno confusione.

void __foo_done(foo* this) 
{ 
    delete this; 
} 

void main() 
{ 
    foo* a = new foo(); 
    __foo_done(a); 
} 

Vedi anche, Is it legal (and moral) for a member function to say delete this?

Answer 4

Calling delete this è una cattiva idea. Chiunque chiama new deve chiamare lo delete. Da qui i problemi evidenziati nelle altre risposte.

Inoltre è possibile avere perdite di memoria/comportamento non definito durante la costruzione di una matrice di oggetti.

Answer 5

In entrambi i casi il tuo heap verrà danneggiato. Naturalmente, non è possibile utilizzare nell'opzione 2 "->" se il valore di sinistra (in questo caso, "a") non è un puntatore, la forma corretta nell'opzione 2 sarebbe a.done(); Ma sì, dovresti ottenere un danneggiamento dell'heap se provi a eliminare 1) cosa è già stato eliminato, o 2) variabile locale.

La chiamata "elimina questo" è tecnicamente valida e libera la memoria.

EDIT ero curioso ed effettivamente provato questo:

class foo 
{ 
public: 
    foo(){} 
    ~foo(){} 
    void done() { delete this; } 
    void test() { x = 2; } 
    int getx() { return x; } 
private: 
    int x; 
} ; 


int main(int argc, char* argv[]) 
{ 
    foo *a = new foo(); 
    a->done(); 
    a->test(); 
    int x = a->getx(); 
    printf("%i\n", x); 
    return x; 
} 

Una chiamata a printf riuscirà, e x terrà il valore 2.

Answer 6

Sarei molto cauto sul contesto in cui si libera memoria. Mentre si chiama "elimina questo;" tenterà di liberare la memoria associata alla struttura della classe, tale operazione non ha modo di dedurre il contesto dell'allocazione di memoria originale, cioè, se è allocata dall'heap o dallo stack. Il mio consiglio è di rielaborare il codice in modo che l'operazione di deallocazione venga invocata da un contesto esterno. Si noti che questo è diverso dal deallocare le strutture interne alla classe, in tal caso, utilizzare il distruttore.

Answer 7

Questa domanda ha avuto risposta, ma aggiungerò un nuovo punto che se la classe chiama elimina questo, è necessario rendere privato il distruttore.

Ciò garantisce che solo la classe possa cancellare se stessa.

Se si rende privato il proprio destructor, entrambi i campioni di codice non verranno compilati.