enable_shared_from_this

Purpose

The header <boost/enable_shared_from_this.hpp> defines the class template enable_shared_from_this. It is used as a base class that allows a shared_ptr or a weak_ptr to the current object to be obtained from within a member function.

enable_shared_from_this<T> defines two member functions called shared_from_this that return a shared_ptr<T> and shared_ptr<T const>, depending on constness, to this. It also defines two member functions called weak_from_this that return a corresponding weak_ptr.

Example

#include <boost/enable_shared_from_this.hpp>
#include <boost/shared_ptr.hpp>
#include <cassert>

class Y: public boost::enable_shared_from_this<Y>
{
public:

    boost::shared_ptr<Y> f()
    {
        return shared_from_this();
    }
};

int main()
{
    boost::shared_ptr<Y> p(new Y);
    boost::shared_ptr<Y> q = p->f();
    assert(p == q);
    assert(!(p < q || q < p)); // p and q must share ownership
}

Synopsis

namespace boost
{

template<class T> class enable_shared_from_this
{
public:

    shared_ptr<T> shared_from_this();
    shared_ptr<T const> shared_from_this() const;

    weak_ptr<T> weak_from_this() noexcept;
    weak_ptr<T const> weak_from_this() const noexcept;
}

}

`template<class T> shared_ptr<T> enable_shared_from_this<T>::shared_from_this();`

`template<class T> shared_ptr<T const> enable_shared_from_this<T>::shared_from_this() const;`

Requires: enable_shared_from_this<T> must be an accessible base class of T. *this must be a subobject of an instance t of type T.

Returns: If a shared_ptr instance p that owns t exists, a shared_ptr<T> instance r that shares ownership with p.

Postconditions: r.get() == this.

Throws: bad_weak_ptr when no shared_ptr owns *this.

`template<class T> weak_ptr<T> enable_shared_from_this<T>::weak_from_this() noexcept;`

`template<class T> weak_ptr<T const> enable_shared_from_this<T>::weak_from_this() const noexcept;`

Requires: enable_shared_from_this<T> must be an accessible base class of T. *this must be a subobject of an instance t of type T.

Returns: If a shared_ptr instance p that owns t exists or has existed in the past, a weak_ptr<T> instance r that shares ownership with p. Otherwise, an empty weak_ptr.