RE: [Boost-Users] Is intrusive_ptr the thing to use?
From: Peter Dimov [mailto:pdimov@mmltd.net]
From: "Hickman, Greg" <greg.hickman@lmco.com>
From: Peter Dimov [mailto:pdimov@mmltd.net] If 'f' is virtual, have the object store a weak_ptr to itself:
class X { private:
weak_ptr<X> weak_this;
X(); X(X const &); X& operator=(X const &);
public:
static shared_ptr<X> create() { shared_ptr<X> px(new X); px->weak_this = px; return px; }
I must be missing something here, because it appears as though you can't derive a Y from X and still initialize X::weak_this.
You could simply make X::weak_this and X::X() protected... although if you follow the design rule that says that non-leaf classes should be abstract (and if possible contain no data) this shouldn't be necessary, as X as pictured above would be a leaf.
Its seems the leaf itself must implement the factory method/weak_this idiom. This initially didn't seem like a good idea in our case since clients write the leaves - we only provide X. But on second thought, perhaps two alternatives are (1) provide a helper template for clients to use when deriving from X to automatically declare the static create()/weak_this pair, or (2) use an intrusive reference counting approach for X. If an intrusive approach ultimately works better for us, what should I do as a boost 1.29.0 user: use counted_base/shared_from_this, or intrusive_ptr (which I admittedly haven't even looked at)? Any suggestions you have are more than welcome. -Greg
Its seems the leaf itself must implement the factory method/weak_this idiom. This initially didn't seem like a good idea in our case since clients write the leaves - we only provide X. But on second thought, perhaps two alternatives are (1) provide a helper template for clients to use when deriving from X to automatically declare the static create()/weak_this
From: "Hickman, Greg" <greg.hickman@lmco.com> [...] pair, Yes, this is what I have done in the CVS with enable_shared_from_this. You could provide template<class T> class enable_shared_from_this { private: weak_ptr<T> weak_this; public: static shared_ptr<T> create() { shared_ptr<T> pt(new T); pt->weak_this = pt; return pt; } shared_ptr<T> shared_from_this() { shared_ptr<T> pt(weak_this); return pt; } }; and let clients define their leaves as class leaf: public enable_shared_from_this<leaf> { // ... };
or (2) use an intrusive reference counting approach for X.
If an intrusive approach ultimately works better for us, what should I do as a boost 1.29.0 user: use counted_base/shared_from_this, or intrusive_ptr (which I admittedly haven't even looked at)?
The counted_base/shared_from_this mechanism will not be present in the next release, so if the above doesn't work for you, it seems that intrusive_ptr would be a better choice.
participants (1)
-
Hickman, Greg -
Peter Dimov