Stocker pointeur faible à l'auto

je travaille avec une base de codes qui a été partiellement implémentée par quelqu'un qui était amoureux de solutions trop complexes à des problèmes simples (par exemple des classes de template avec deux paramètres qui n'ont été instanciés que pour une paire de types). Une chose qu'elle a fait était de créer des objets dans un pointeur intelligent, puis avoir l'objet stocker un pointeur faible à lui-même.

class MyClass {
    //...
    boost::weak_ptr<MyClass> m_self;
    //...
};

boost::shared_ptr<MyClass>
Factory::Factory::Factory::CreateMyClass() {
    boost::shared_ptr<MyClass> obj(new MyClass(...));
    boost::weak_ptr<MyClass> p(obj);
    obj->storeSelfPointer(p);
    return obj;
}

la classe procède ensuite à l'utilisation de m_self en le verrouillant et en faisant circuler le résultat partagé pointeur.

Pour la vie de moi, je n'arrivons pas à comprendre ce qu'elle essayait d'accomplir. Y a-t-il un modèle ou une idée qui expliquerait cette mise en œuvre? Il me semble que c'est complètement inutile et je tiens à refactoriser.

EDIT: je dois mentionner qu'aucun des endroits qui utilisent le pointeur intelligent résultant obtenu en verrouillant m_self ne retient le pointeur intelligent.

14
demandé sur James Davidoff 2014-06-26 04:26:50
la source

1 ответов

Une utilisation possible de cette "conception" pourrait être d'utiliser m_self.lock() pour générer des pointeurs partagés à partir de cela.

si vous supprimez ce membre pointeur faible, le nombre de référence tient par le pointeur partagé généré à partir de this serait incorrect.

Il réalise le même que std::enable_shared_from_this, interestly enough,cppreference.com mentionne cette conception:

une implémentation commune pour enable_shared_from_this est de tenir une faible référence (telle que std:: weak_ptr) à ceci. Les constructeurs de std::shared_ptr détecter la présence d'un enable_shared_from_this de base et assignez le std::shared_ptr nouvellement créé au stocké en interne référence faible

Et le C++ standard, la section § 20.8.2.4 10 , de parler de la même mise en œuvre possible :

les constructeurs shared_ptr qui créent des pointeurs uniques peuvent détecter présence d'une enable_partagée_- from_this base et assignez le nouveau créé shared_ptr à son __weak_this membre


Remaniement Possible:

  • si vous utilisez C++11, Vous pouvez supprimer le std::weak_ptr membre, et hérite publiquement de std::enable_shared_from_this<T>. Vous devriez récupérer un pointeur partagé à partir de cela en appelant shared_from_this().

  • si vous n'utilisez pas C++11 mais pouvez utiliser boost, utilisez boost::enable_shared_from_this voir le boost documentation. Vous devriez récupérer un pointeur partagé à partir de cela en appelant shared_from_this().

  • si vous n'utilisez pas C++11, et ne pouvez pas utiliser boost, vous pouvez apporter l'implémentation proposée du standard à votre base de code, il est assez court:

Code: (copié à partir du § 20.8.2.4 - 11, supprimer des traits de soulignement, et vous voudrez probablement pour le renommer)

template<class T> class enable_shared_from_this {
    private:
     weak_ptr<T> __weak_this;
    protected:
     constexpr enable_shared_from_this() : __weak_this() { }
     enable_shared_from_this(enable_shared_from_this const &) { }
     enable_shared_from_this& operator=(enable_shared_from_this const &) { return *this; }
     ~enable_shared_from_this() { }
    public:
     shared_ptr<T> shared_from_this() { return shared_ptr<T>(__weak_this); }
     shared_ptr<T const> shared_from_this() const { return shared_ptr<T const>(__weak_this); }
};

et utilisez shared_from_this() pour faire partagé pointeur. Si vous copiez ce code, notez que construire des pointeurs partagés à partir de ce code par d'autres moyens serait . Les constructeurs de pointeurs partagés doivent être modifiés (comme expliqué par la citation standard ci-dessus).

17
répondu quantdev 2014-11-29 07:17:04
la source

Autres questions sur c++ smart-pointers weak-ptr