c++ enable_shared_from_this

        std::enable_shared_from_this 是一个类模板，那它是用来干嘛的呢？光看它的名字可能可以猜出它是：返回指向当前对象的shared_ptr智能指针。在说明它的作用前我们可以看一下如下代码：

#include <memory>
#include <iostream>

class A
{
public:
    A()
    {
        std::cout << "A()" << std::endl;
    }

    ~A()
    {
        std::cout << "~A()" << std::endl;
    }

    std::shared_ptr<A> getSharedPtr()
    {
        std::shared_ptr<A> ptr(this);
        return ptr;
    }
};


int main()
{
    std::shared_ptr<A> ptr1(new A());
    std::shared_ptr<A> ptr2 = ptr1->getSharedPtr();

    return 0;
}

类 A 中有一个函数 getSharedPtr() 函数，用于返回指向当前对象的一个智能打针，就是用 this 构造了一个智能指针进行返回，我们看一下这样会不会有问题呢？执行结果如下：

执行没有异常，那这样用是正确的吗？在回答前我们再来看一下修改的代码：

#include <memory>
#include <iostream>

class A
{
public:
    A(): mPtr(new int(10))
    {
        std::cout << "A(), *mPtr = " << *mPtr <<std::endl;
    }

    ~A()
    {
        std::cout << "~A()" << std::endl;
        delete mPtr;
        mPtr = nullptr;
    }

    std::shared_ptr<A> getSharedPtr()
    {
        std::shared_ptr<A> ptr(this);
        return ptr;
    }
private:
    int *mPtr;
};


int main()
{
    std::shared_ptr<A> ptr1(new A());
    std::shared_ptr<A> ptr2 = ptr1->getSharedPtr();


    return 0;
}

 类 A 里多加了一个指针成员变量 mPtr，同时在构造函数里 mPtr 指向了 new 出来的内存空间，初始化为 10；在析构函数里 delete mPtr，这些都属于正常操作，那执行结果如何呢？

 可以看出是 free 了无效的指针导致程序崩溃。我们应该能看到是重复释放的问题，这里我们将裸指针赋给了智能指针，这样做潜在的危险就是对象被多次释放。我们加两行打印看一下，打印出智能指针的引用计数是怎样的：

#include <memory>
#include <iostream>

class A
{
public:
    A(): mPtr(new int(10))
    {
        std::cout << "A(), *mPtr = " << *mPtr <<std::endl;
    }

    ~A()
    {
        std::cout << "~A()" << std::endl;
        delete mPtr;
        mPtr = nullptr;
    }

    std::shared_ptr<A> getSharedPtr()
    {
        std::shared_ptr<A> ptr(this);
        return ptr;
    }
private:
    int *mPtr;
};


int main()
{
    std::shared_ptr<A> ptr1(new A());
    std::shared_ptr<A> ptr2 = ptr1->getSharedPtr();

    std::cout << ptr1.use_count() << std::endl;
    std::cout << ptr2.use_count() << std::endl;

    return 0;
}

 智能指针 ptr1 和 ptr2 的引用计数都是 1，说明它们指向的不是同一个资源（这里可能会有人疑惑两个智能指针指向同一个地址，怎么引用计数没有增加呢？而且在 shared_ptr 的实现中，是不是只在拷贝构造和赋值操作operator=才会增加引用计数呢？）。所以这里两个智能指针，释放两次，而这两次释放的是同一个地址，所以崩溃了。那 enable_shread_from_this 的作用就是解决这个问题，使用如下：

#include <memory>
#include <iostream>

class A: public std::enable_shared_from_this<A>
{
public:
    A()
    {
        std::cout << "A()" << std::endl;
    }

    ~A()
    {
        std::cout << "~A()" << std::endl;
        delete ptr;
        ptr = nullptr;
    }

    std::shared_ptr<A> getSharedPtr()
    {
        return shared_from_this();
    }
private:
    int *ptr;
};


int main()
{
    std::shared_ptr<A> ptr1(new A());
    std::shared_ptr<A> ptr2 = ptr1->getSharedPtr();

    std::cout << ptr1.use_count() << std::endl;
    std::cout << ptr2.use_count() << std::endl; 
    return 0;
}

我们看到，两个智能指针的引用计数都为2，这两个智能指针指向了相同的资源，在 main 函数退出后，两个智能指针释放，引用计数变为 0，资源释放正常。