谈谈 shared_ptr 的那些坑

共享所有权

　　一个动态分配的对象可以在多个shared_ptr之间共享，这是因为shared_ptr支持 copy 操作：

shared_ptr<string> ptr1{ new string("hello") };
auto ptr2 = ptr1;　// copy constructor

原理介绍

　　shared_ptr内部包含两个指针，一个指向对象，另一个指向控制块(control block)，控制块中包含一个引用计数和其它一些数据。由于这个控制块需要在多个shared_ptr之间共享，所以它也是存在于 heap 中的。shared_ptr对象本身是线程安全的，也就是说shared_ptr的引用计数增加和减少的操作都是原子的。

　　通过unique_ptr来构造shared_ptr是可行的：

unique_ptr<string> p1{ new string("senlin") };
shared_ptr<string> p2{ std::move(p1) };

shared_ptr 的风险

　　你大概觉得使用智能指针就再也高枕无忧了，不再为内存泄露烦恼了。然而梦想总是美好的，使用shared_ptr时，不可避免地会遇到循环引用的情况，这样容易导致内存泄露。循环引用就像下图所示，通过shared_ptr创建的两个对象，同时它们的内部均包含shared_ptr指向对方。

// 一段内存泄露的代码
struct Son;

struct Father　{
    shared_ptr<Son> son_;
};

struct Son {
    shared_ptr<Father> father_;
};

int main() 
{
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();
    father->son_ = son;
    son->father_ = father;
  
    return 0;
}

　　分析一下main函数是如何退出的，一切就都明了：

• main函数退出之前，Father和Son对象的引用计数都是2。
• son指针销毁，这时Son对象的引用计数是1。
• father指针销毁，这时Father对象的引用计数是1。
• 由于Father对象和Son对象的引用计数都是1，这两个对象都不会被销毁，从而发生内存泄露。

---

　　为避免循环引用导致的内存泄露，就需要使用weak_ptr，weak_ptr并不拥有其指向的对象，也就是说，让weak_ptr指向shared_ptr所指向对象，对象的引用计数并不会增加：

auto ptr = make_shared<string>("senlin");
weak_ptr<string> wp1{ ptr };
cout << "use count: " << ptr.use_count() << endl;// use count: 1

　　使用weak_ptr就能解决前面提到的循环引用的问题，方法很简单，只要让Son或者Father包含的shared_ptr改成weak_ptr就可以了。

// 修复内存泄露的问题
struct Son;

struct Father　{
    shared_ptr<Son> son_;
};

struct Son {
    weak_ptr<Father> father_;
};

int main() 
{
    auto father = make_shared<Father>();
    auto son = make_shared<Son>();
    father->son_ = son;
    son->father_ = father;
  
    return 0;
}

　　同样，分析一下main函数退出时发生了什么：

• main函数退出前，Son对象的引用计数是2，而Father的引用计数是1。
• son指针销毁，Son对象的引用计数变成1。
• father指针销毁，Father对象的引用计数变成0，导致Father对象析构，Father对象的析构会导致它包含的son_指针被销毁，这时Son对象的引用计数变成0，所以Son对象也会被析构。

---

　　然而，weak_ptr并不是完美的，因为weak_ptr不持有对象，所以不能通过weak_ptr去访问对象的成员，例如：

struct Square {
    int size = 0;
};

auto sp = make_shared<Square>();
weak_ptr<Square> wp{ sp };
cout << wp->size << endl;   // compile-time ERROR

　　你可能猜到了，既然shared_ptr可以访问对象成员，那么是否可以通过weak_ptr去构造shared_ptr呢？事实就是这样，实际上weak_ptr只是作为一个转换的桥梁（proxy），通过weak_ptr得到shared_ptr，有两种方式：

• 调用weak_ptr的lock()方法，要是对象已被析构，那么lock()返回一个空的shared_ptr。
• 将weak_ptr传递给shared_ptr的构造函数，要是对象已被析构，则抛出std::exception异常。

　　既然weak_ptr不持有对象，也就是说weak_ptr指向的对象可能析构了，但weak_ptr却不知道。所以需要判断weak_ptr指向的对象是否还存在，有两种方式：

• weak_ptr的use_count()方法，判断引用计数是否为0。
• 调用weak_ptr的expired()方法，若对象已经被析构，则expired()将返回true。

　　转换过后，就可以通过shared_ptr去访问对象了：

auto sp = make_shared<Square>();
weak_ptr<Square> wp{ sp };
    
if (!wp.expired()) 
{
    auto ptr = wp.lock();      // get shared_ptr
    cout << ptr->size << endl;
}

销毁操作

　　为shared_ptr指定 deleter 的做法很简单：

shared_ptr<string> ptr( new string("hello"), 
                        []( string *p ) {
                            cout << "delete hello" << endl;
                        });
ptr = nullptr;
cout << "Before the end of main()" << endl;
/**
delete hello
Before the end of main()
**/

　　与unique_ptr不同，标准库并不提供shared_ptr<T[]>，因此，使用shared_ptr处理数组时需要显示指定删除行为，例如：

shared_ptr<string> ptr1( new string[10], 
                         []( string *p ) {
                             delete[] p;
                         });
shared_ptr<string> ptr2( new string[10],
                         std::default_delete<string[]>() );

　　由于不存在shared_ptr<T[]>，我们无法使用[]来访问数组中的元素，实际上无法访问到数组中的元素。也就是说使用shared_ptr来指向数组意义并不大。若想要数组在多个shared_ptr之间共享，可以考虑使用shared_ptr<vector>或shared_ptr<array>。

更多陷阱

　　使用shared_ptr时，注意不能直接通过同一个 raw pointer 指针来构造多个shared_ptr：

int *p = new int{10};
shared_ptr<int> ptr1{ p };
shared_ptr<int> ptr2{ p };         // ERROR

　　很明显，每次通过 raw pointer 来构造shared_ptr时候就会分配一个控制块，这时存在两个控制块，也就是说存在两个引用计数。这显然是错误的，因为当这两个shared_ptr被销毁时，对象将会被delete两次。

---

　　考虑到this也是 raw pointer，所以一不小心就会用同一个this去构造多个shared_ptr了，就像这样：

class Student
{
public:
    Student( const string &name ) : name_( name ) { }

    void addToGroup( vector<shared_ptr<Student>> &group ) {
        group.push_back( shared_ptr<Student>(this) );          // ERROR
    }
private:
    string name_;
};

　　每次调用addToGroup()时都会创建一个控制块，所以这个对象会对应多个引用计数，最终这个对象就会被delete多次，导致运行出错。解决这个问题很简单，只要让std::enable_shared_from_this<Student>作为Student的基类：

class Student : public std::enable_shared_from_this<Student>
{
public:
    Student( const string &name ) : name_( name ) { }

    void addToGroup( vector<shared_ptr<Student>> &group ) {
        group.push_back( shared_from_this() );              // OK
    }
private:
    string name_;
};

　　需要注意，调用shared_from_this()之前需要确保对象被share_ptr所持有，理解这一点是很容易的，因为只有当对象被shared_ptr所持有，使用shared_from_this()所返回的shared_ptr才会指向同一个对象。

vector<shared_ptr<Student>> group;

// Good: ensure object be owned by shared_ptr
auto goodStudent = make_shared<Student>( "senlin" );
goodStudent->addToGroup( group );

Student badStudent1( "bad1" );
badStudent1.addToGroup( group );           // ERROR

auto badStudent2 = new Student( "bad2" );
badStudent2->addToGroup( group );          // ERROR

　　在调用shared_from_this()之前需要确保对象被shared_ptr所持有，要使得对象被shared_ptr所持有，对象首先要初始化（调用构造函数），所以一定不能在Student的构造函数中调用shared_from_this()：

class Student : public std::enable_shared_from_this<Student>
{
public:
    Student( const string &name, vector<shared_ptr<Student>> &group )
        : name_( name ) 
    {
        // ERROR: shared_from_this() can't be call in object's constructor
        group.push_back( shared_from_this() );
    }
private:
    string name_;
};

---

　　好了，那么问题来了：

• 要怎样才能防止用户以不正确的方式来创建Student对象呢？
• 同时也要使得，我们可以使用不同的构造方式来创建Student对象。

　　可以将Student的构造函数声明为private的，因此，用户无法直接创建Student对象。另一方面，增加create()成员函数，在这个函数里面，我们使用 C++11 的 variadic templates 特性，调用Student的构造函数来构造对象：

class Student : public std::enable_shared_from_this<Student>
{
private:
    Student( const string &name ) : name_( name ) { }

    Student( const Student &rhs ) : name_( rhs.name_ ) { }

    // can have other constructor
public:
    template <typename... Args>
    static shared_ptr<Student> create( Args&&... args ) {
        return shared_ptr<Student>(new Student(std::forward<Args>(args)...));
    }

    void addToGroup( vector<shared_ptr<Student>> &group ) {
        group.push_back( shared_from_this() );
    }
private:
    string name_;
};

　　通过create()保证了用户创建的对象总是被shared_ptr所持有，可以将create()想象成Student构造函数的别名：

vector<shared_ptr<Student>> group;
auto student1 = Student::create("senlin");
student1->addToGroup(group);
cout << "student1.use_count() = " << student1.use_count() << endl;
// student1.use_count() = 2

性能考虑

shared_ptr<std::string> ptr{ new string("hello") };

　　使用这种方式创建shared_ptr时，需要执行两次new操作，一次在 heap 上为string("hello")分配内存，另一次在 heap 上为控制块分配内存。使用make_shared来创建shared_ptr会高效，因为make_shared仅使用new操作一次，它的做法是在 heap 上分配一块连续的内存用来容纳string("hello")和控制块。同样，当shared_ptr的被析构时，也只需一次delete操作。

auto ptr = std::make_shared<std::string>("hello");

参考资料

• Effective Modern C++: 42 Specific Ways to Improve Your Use of C++11 and C++14
• StackOverflow: what is the usefulness of enable_shared_from_this
• Safely using enable_shared_from_this
• The C++ Standard Library Second Edition
• StackOverflow: Is make_shared really more efficient than new?
• The C++ Programming Language 4th Edition