Question

I am making extensive use of boost:shared_ptr in my code. In fact, most of the objects that are allocated on the heap are held by a shared_ptr. Unfortunately this means that I can’t pass this into any function that takes a shared_ptr. Consider this code:

void bar(boost::shared_ptr<Foo> pFoo) {     ... }  void Foo::someFunction() {     bar(this); } 

There are two problems here. First, this won’t compile because the T* constructor for shared_ptr is explicit. Second, if I force it to build with bar(boost::shared_ptr<Foo>(this)) I will have created a second shared pointer to my object that will eventually lead to a double-delete.

This brings me to my question: Is there any standard pattern for getting a copy of the existing shared pointer you know exists from inside a method on one of those objects? Is using intrusive reference counting my only option here?

Answer 1

You can derive from enable_shared_from_this and then you can use ‘shared_from_this()’ instead of ‘this’ to spawn a shared pointer to your own self object.

Example in the link:

#include <boost/enable_shared_from_this.hpp>  class Y: public boost::enable_shared_from_this<Y> { public:      shared_ptr<Y> f()     {         return shared_from_this();     } }  int main() {     shared_ptr<Y> p(new Y);     shared_ptr<Y> q = p->f();     assert(p == q);     assert(!(p < q || q < p)); // p and q must share ownership } 

It’s a good idea when spawning threads from a member function to boost::bind to a shared_from_this() instead of this. It will ensure that the object is not released.