shared_ptr enable_shared_from_this - C++11, 3 of n

#include <memory>

struct S: enable_shared_from_this<S>

{

};

Don't do this:

S *p = new S;

shared_ptr<S> sp2 = p->shared_from_this(); // throws std::bad_weak_ref

Do this:

shared_ptr<S> p(new S);

shared_ptr<S> sp2 = p->shared_from_this();

Rule: when a class inherits from enable_shared_from_this, it almost always means it should work with shared_ptr together.

What happened behind the scene for shared_ptr<S> p(new S) ?

(1) enable_shared_from_this construct is called

(2) S constructor is called

(3) shared_ptr constructor is called (the magic happens here)

|

| -> __enable_shared_from_this_helper is called in shared_ptr constructor

|

|-> enable_shared_from_this::_M_weak_assign is called

|

|-> weak_ptr<_Tp>::._M_assign(__p, __n);

(called on mutable enable_shared_from_this::_M_weak_this instance in

struct S object. This calls sets (inits) the weak_ptr in struct S object)

|

|-> Set weak_ptr<_Tp>::_M_ptr and

weak_ptr<_Tp>:: _M_refcount (__weak_count<_Lp>)



Why the first case throws ?

// enabled_shared_from_this::shared_from_this

__shared_ptr<_Tp, _Lp> shared_from_this() { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }

// __shared_ptr constructor with weak_ptr

template<typename _Tp1>

explicit __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) : _M_refcount(__r._M_refcount)// may throw

{

__glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)

// It is now safe to copy __r._M_ptr, as

// _M_refcount(__r._M_refcount) did not throw.

_M_ptr = __r._M_ptr;

}

// __share_count constructor with __weak_count

// Throw bad_weak_ptr when __r._M_get_use_count() == 0.

explicit __shared_count(const __weak_count<_Lp>& __r): _M_pi(__r._M_pi)

{

if (_M_pi != 0)

_M_pi->_M_add_ref_lock();

else

__throw_bad_weak_ptr();

}