std::shared_ptr of this

by

There is std::enable_shared_from_this just for this purpose. You inherit from it and you can call .shared_from_this() from inside the class. Also, you are creating circular dependencies here that can lead to resource leaks. That can be resolved with the use of std::weak_ptr. So your code might look like this (assuming children rely on existence of parent and not the other way around):

class A;
class B;

class A
    : public std::enable_shared_from_this<A>
{
public:
    void addChild(std::shared_ptr<B> child)
    {
        children.push_back(child);

        // like this
        child->setParent(shared_from_this());  // ok
        //               ^^^^^^^^^^^^^^^^^^
    }

private:     
    // note weak_ptr   
    std::list<std::weak_ptr<B>> children;
    //             ^^^^^^^^
};

class B
{
public:
    void setParent(std::shared_ptr<A> parent)
    {
        this->parent = parent;
    }

private:
    std::shared_ptr<A> parent;
};

Note however, that calling .shared_from_this() requires that this is owned by std::shared_ptr at the point of call. This means that you cannot create such object on stack anymore, and generally cannot call .shared_from_this() from within a constructor or destructor.

More Related Contents:

  1. Difference between this. and this->
  2. How do I call ::std::make_shared on a class with only protected or private constructors?
  3. When should I make explicit use of the `this` pointer?
  4. In a templated derived class, why do I need to qualify base class member names with “this->” inside a member function?
  5. Difference in make_shared and normal shared_ptr in C++
  6. What is the ‘this’ pointer?
  7. std::shared_ptr thread safety
  8. Why shared_from_this can’t be used in constructor from technical standpoint?
  9. Should we pass a shared_ptr by reference or by value?
  10. C++ – passing references to std::shared_ptr or boost::shared_ptr
  11. Passing shared pointers as arguments
  12. How to avoid memory leak with shared_ptr?
  13. How to release pointer from boost::shared_ptr?
  14. Passing shared_ptr as shared_ptr
  15. How is the std::tr1::shared_ptr implemented?
  16. Where is shared_ptr?
  17. Excessive use of `this` in C++ [duplicate]
  18. std::shared_ptr thread safety explained
  19. Is it safe to use the “this” pointer in an initialization list?
  20. Is boost shared_ptr thread safe?
  21. Should I pass a shared_ptr by reference? [duplicate]
  22. Is make_shared really more efficient than new?
  23. How do shared pointers work?
  24. Why does unique_ptr take two template parameters when shared_ptr only takes one?
  25. Using shared_ptr in dll-interfaces
  26. What is the cyclic dependency issue with shared_ptr?
  27. Does C++11 unique_ptr and shared_ptr able to convert to each other’s type?
  28. What does ‘return *this’ mean in C++?
  29. Problems using member function as custom deleter with std::shared_ptr
  30. Conversion from boost::shared_ptr to std::shared_ptr?

Leave a Comment