它使您能够获得一个有效的shared_ptr实例，当您只有这个时。没有它，你将无法获得一个shared_ptr到this，除非你已经有一个作为成员。下面的例子来自enable_shared_from_this的boost文档:

class Y: public 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
}

方法f()返回一个有效的shared_ptr，即使它没有成员实例。注意，你不能简单地这样做:

class Y: public enable_shared_from_this<Y>
{
public:

    shared_ptr<Y> f()
    {
        return shared_ptr<Y>(this);
    }
}

返回的共享指针将具有不同于“正确”的引用计数，当对象被删除时，其中一个指针将丢失并保留一个悬空引用。

enable_shared_from_this已经成为c++ 11标准的一部分。你也可以从那里和从boost得到它。

来自Dobbs博士关于弱指针的文章，我认为这个例子更容易理解(来源:http://drdobbs.com/cpp/184402026):

.．.这样的代码将无法正常工作:

int *ip = new int;
shared_ptr<int> sp1(ip);
shared_ptr<int> sp2(ip);

两个shared_ptr对象都不知道对方的存在，所以当它们被销毁时都将尝试释放资源。这通常会导致问题。

类似地，如果一个成员函数需要一个shared_ptr对象，该对象拥有被调用的对象，它不能动态地创建一个对象:

struct S
{
  shared_ptr<S> dangerous()
  {
     return shared_ptr<S>(this);   // don't do this!
  }
};

int main()
{
   shared_ptr<S> sp1(new S);
   shared_ptr<S> sp2 = sp1->dangerous();
   return 0;
}

This code has the same problem as the earlier example, although in a more subtle form. When it is constructed, the shared_ptr object sp1 owns the newly allocated resource. The code inside the member function S::dangerous doesn't know about that shared_ptr object, so the shared_ptr object that it returns is distinct from sp1. Copying the new shared_ptr object to sp2 doesn't help; when sp2 goes out of scope, it will release the resource, and when sp1 goes out of scope, it will release the resource again.

避免这个问题的方法是使用类模板enable_shared_from_this。模板接受一个模板类型参数，它是定义托管资源的类的名称。该类必须反过来从模板公开派生;是这样的:

struct S : enable_shared_from_this<S>
{
  shared_ptr<S> not_dangerous()
  {
    return shared_from_this();
  }
};

int main()
{
   shared_ptr<S> sp1(new S);
   shared_ptr<S> sp2 = sp1->not_dangerous();
   return 0;
}

在执行此操作时，请记住调用shared_from_this的对象必须属于shared_ptr对象。这行不通:

int main()
{
   S *p = new S;
   shared_ptr<S> sp2 = p->not_dangerous();     // don't do this
}

注意，使用boost::intrusive_ptr不会遇到这个问题。 这通常是一种更方便的方法来解决这个问题。

以下是我的解释，从具体的角度来看(上面的答案对我来说不“合适”)。*注意，这是调查Visual Studio 2012附带的shared_ptr和enable_shared_from_this的源代码的结果。也许其他编译器实现enable_shared_from_this的方式不同…*

enable_shared_from_this<T>为T添加了一个私有的weak_ptr<T>实例，该实例保存了T实例的“一个真实引用计数”。

因此，当你第一次在一个新的T*上创建一个shared_ptr<T>时，这个T*的内部weak_ptr初始化为1的refcount。新的shared_ptr基本上回到了这个weak_ptr。

然后，T可以在其方法中调用shared_from_this来获得shared_ptr<T>的实例，该实例返回到相同的内部存储引用计数。这样，你总是有一个地方存储T*的引用计数，而不是有多个不知道彼此的shared_ptr实例，每个实例都认为他们是shared_ptr，负责引用计数T，并在他们的引用计数为零时删除它。

这在c++11及以后的版本中是完全相同的:它是为了启用作为共享指针返回this的能力，因为这给了你一个原始指针。

换句话说，它允许您像这样转换代码

class Node {
public:
    Node* getParent const() {
        if (m_parent) {
            return m_parent;
        } else {
            return this;
        }
    }

private:

    Node * m_parent = nullptr;
};           

到这个:

class Node : std::enable_shared_from_this<Node> {
public:
    std::shared_ptr<Node> getParent const() {
        std::shared_ptr<Node> parent = m_parent.lock();
        if (parent) {
            return parent;
        } else {
            return shared_from_this();
        }
    }

private:

    std::weak_ptr<Node> m_parent;
};           

在一个特殊的情况下，我发现enable_shared_from_this非常有用:使用异步回调时的线程安全。

假设类Client有一个AsynchronousPeriodicTimer类型的成员:

struct AsynchronousPeriodicTimer
{
    // call this periodically on some thread...
    void SetCallback(std::function<void(void)> callback); 
    void ClearCallback(); // clears the callback
}

struct Client
{
    Client(std::shared_ptr< AsynchronousPeriodicTimer> timer) 
        : _timer(timer)

    {
        _timer->SetCallback(
            [this]
            () 
            {
                assert(this); // what if 'this' is already dead because ~Client() has been called?
                std::cout << ++_counter << '\n';
            }
            );
    }
    ~Client()
    {
        // clearing the callback is not in sync with the timer, and can actually occur while the callback code is running
        _timer->ClearCallback();
    }
    int _counter = 0;
    std::shared_ptr< AsynchronousPeriodicTimer> _timer;
}

int main()
{
    auto timer = std::make_shared<AsynchronousPeriodicTimer>();
    {
        auto client = std::make_shared<Client>(timer);
        // .. some code    
        // client dies here, there is a race between the client callback and the client destructor           
    }
}

客户端类向定时计时器订阅了一个回调函数。一旦客户端对象超出作用域，客户端回调函数和客户端析构函数之间就存在竞争条件。回调可以用悬空指针调用!

解决方案:使用enable_shared_from_this在回调调用期间延长对象的生存期。

struct Client : std::enable_shared_from_this<Client>
{
Client(std::shared_ptr< AsynchronousPeriodicTimer> timer) 
    : _timer(timer)

    {

    }

    void Init()
    {
        auto captured_self = weak_from_this(); // weak_ptr to avoid cyclic references with shared_ptr

        _timer->SetCallback(
        [captured_self]
        () 
        {
            if (auto self = captured_self.lock())
            {
                // 'this' is guaranteed to be non-nullptr. we managed to promote captured_self to a shared_ptr           
                std::cout << ++self->_counter << '\n';
            }

        }
        );
    }
    ~Client()
    {
        // the destructor cannot be called while the callback is running. shared_ptr guarantees this
        _timer->ClearCallback();
    
    }
    int _counter = 0;
    std::shared_ptr< AsynchronousPeriodicTimer> _timer;
}

enable_shared_from_this机制与std::shared_ptr引用计数的固有线程安全性相结合，使我们能够确保当回调代码访问其内部成员时，Client对象不能被销毁。

请注意，Init方法与构造函数分离，因为enable_shared_from_this的初始化过程直到构造函数退出才结束。因此有了额外的方法。从构造函数内部订阅异步回调通常是不安全的，因为回调可能访问未初始化的字段。