Accéder à une variable locale après "supprimer ceci"

Question

J'ai une classe qui utilise un mécanisme de comptage de référence. Les objets de cette classe sont finalement détruits en appelant delete this lorsque le nombre de références tombe à zéro. Ma question est: puis-je utiliser la variable locale sur la pile après delete this? Voici un exemple plus précis:

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

Oui, you may do this, aussi longtemps que la variable membre lui-même est vraiment seulement une référence à un objet extérieur.

(S'il vous plaît pardonnez la réponse précédente mal, je suis confus au sujet de la variable mutex_.)

Answer 2

En général, la seule chose que vous n'êtes pas autorisé à appeler après delete this est tout ce qui fait référence à this. Cela inclut tout membre ou fonction de classe non statique.

Dans votre cas, il est fort probable que RemoveReference ne fonctionnera pas. C'est parce que m points à mutex_ qui n'existe plus après supprimer cela. Votre meilleur pari pourrait bien rendre mutex_ statique.

Edit: Bien que mutex_ des points à une variable externe qui continue d'exister après la classe est supprimée, il n'y a aucune garantie pare-balles que le compilateur ne se référer à mutex_ après la classe est supprimée pour obtenir la valeur de la mutex externe. Il y a de fortes chances que les choses fonctionnent comme prévu, mais je ne crois pas que cela puisse être garanti.

Answer 3

Oui dans ce cas. Votre variable de pile 'm' pointe vers une ressource externe que vous obtenez dans le constructeur

Answer 4

Oui, vous pouvez, mais pourquoi ne pas utiliser le décrément atomique au lieu de décrémenter le compteur sous le mutex? Et avez-vous réellement besoin de protéger (par mutex) la destruction d'objets? En effet, après que le compteur soit 0, le seul fil courant peut accéder à l'objet.

Alors, peut-être il est possible de réécrire votre code comme

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

(ou utiliser Atomics pour Décrémenter et tester le compteur)