Accesso a una variabile locale dopo "Elimina questo"

Question

Ho una classe che utilizza un meccanismo di conteggio dei riferimenti. Gli oggetti di questa classe vengono infine distrutti chiamando lo delete this quando il conteggio dei riferimenti scende a zero. La mia domanda è: posso usare la variabile on-stack locale dopo lo delete this? Ecco un esempio più specifico:

class RefCountedClass 
{ 
public: 
    RefCountedClass(Mutex& m) : 
     mutex_(m) 
    {} 

    . 
    . 
    . 

private: 
    Mutex& mutex_; 

    void RemoveReference() 
    { 
     // As I understand, mutex_ will be destroyed after delete, 
     // but using m is all right because it is on-stack and 
     // references an external object. Am I right? 
     Mutex& m = mutex_; 
     m.Acquire(); 

     --recount_; 
     if (refcount <= 0) delete this; 

     m.Release(); 
    } 
}; 

Answer 1

Sì, you may do this, finché membro variabile stessa è in realtà solo un riferimento ad un oggetto esterno.

(Si prega di perdonare la risposta sbagliata precedente, ero confuso circa la variabile mutex_.)

Answer 2

Generalmente l'unica cosa che non ti è permesso di chiamare dopo delete this è tutto ciò che rende un riferimento a this. Questo include qualsiasi membro o funzione della classe non statica.

Nel tuo caso, c'è una buona possibilità che RemoveReference non funzioni. Questo è il numero m punti a mutex_ che non esiste più dopo l'eliminazione. La tua migliore scommessa potrebbe essere fare mutex_ statico.

Edit: Sebbene mutex_ punta a una variabile esterna che continua ad esistere dopo che la classe viene eliminato, non v'è alcuna garanzia a prova di proiettile che il compilatore non rinviare alla mutex_ dopo che la classe viene eliminato per ottenere il valore della mutex esterno. C'è una buona possibilità che le cose funzionino come previsto, ma non credo che questo possa essere garantito.

Answer 3

Sì in questo caso. La variabile dello stack 'm' punta a una risorsa esterna che si ottiene nel costruttore

Answer 4

Sì, è possibile, ma perché non utilizzare il decremento atomico invece di decrementare il contatore sotto il mutex? E hai effettivamente bisogno di proteggere (da mutex) la distruzione dell'oggetto? Infatti, dopo il contatore diventa 0, l'unico thread corrente può accedere all'oggetto.

Così, forse è possibile riscrivere il codice come

 
    int tmp_count; 
    m.Acquire(); 
     tmp_count= --recount_; 
    m.Release(); 
    if (tmp_count <= 0) delete this; 

(o utilizzare Atomics per decrementare e testare il contatore)