C++智能指针系列：其三、shared_ptr

前面提到的两种智能指针，设计思想都是独占资源。shared_ptr的设计思想是共享资源。一个指针可以被多个shared_ptr管理。采用引用计数法控制析构函数的执行，当shared_ptr发生赋值和拷贝的时候，引用计数加一。当shared_ptr发生析构的时候，引用计数减一。这个看起来特别像jvm里面的引用计数法，实则不然。后文会对原理有详细介绍。

一、shared_ptr的初始化

int main ( )
{
    shared_ptr<Test> sp1(new Test);    //构造函数初始化

    shared_ptr<Test> sp2;          //reset初始化
    sp2.reset(new Test);

    shared_ptr<Test> sp3 = make_shared<Test>();     //make_shared初始化

    shared_ptr<Test> sp4(sp1);      //拷贝构造函数初始化

    shared_ptr<Test> sp5;          //赋值运算符重载初始化
    sp5 = sp1;

    shared_ptr<Test> sp6(move(sp1)); //移动构造函数初始化

    shared_ptr<Test> sp7;          //右值赋值运算符重载初始化
    sp7 = move(sp2);               
}

主要有三种初始化方法：
（1）构造函数初始化；
（2）对于已经构造的shared_ptr对象，可以采用reset的方法重新托管新的内存。
（3）使用make_shared方法初始化，<>中记录托管的指针类型，()中表示托管类型的构造函数参数。后面会指出，优先使用方法(3)
（4）（5）（6）（7）后文有详细解释。

二、引用计数的使用

可以使用use_count函数可以获得当前托管指针的引用计数。

int main ( )
{
    shared_ptr<Test> sp1(new Test);
    cout << "sp1	use_count() = " << sp1.use_count() << endl<<endl;

    shared_ptr<Test> sp2(sp1);
    cout << "sp1	use_count() = " << sp1.use_count() << endl;
    cout << "sp2	use_count() = " << sp2.use_count() << endl<<endl;

    shared_ptr<Test> sp3;
    sp3 = sp1;
    cout << "sp1	use_count() = " << sp1.use_count() << endl;
    cout << "sp2	use_count() = " << sp2.use_count() << endl;
    cout << "sp3	use_count() = " << sp3.use_count() << endl<<endl;

    sp1.reset();
    cout << "sp1	use_count() = " << sp1.use_count() << endl;
    cout << "sp2	use_count() = " << sp2.use_count() << endl;
    cout << "sp3	use_count() = " << sp3.use_count() << endl<<endl;

    sp2= nullptr;
    cout << "sp1	use_count() = " << sp1.use_count() << endl;
    cout << "sp2	use_count() = " << sp2.use_count() << endl;
    cout << "sp3	use_count() = " << sp3.use_count() << endl<<endl;

}

输出结果：

Test start...
sp1     use_count() = 1

sp1     use_count() = 2
sp2     use_count() = 2

sp1     use_count() = 3
sp2     use_count() = 3
sp3     use_count() = 3

sp1     use_count() = 0
sp2     use_count() = 2
sp3     use_count() = 2

sp1     use_count() = 0
sp2     use_count() = 0
sp3     use_count() = 1

Test end...

对于拷贝构造函数与赋值之后，引用计数加一，这个绝对没问题，但是如果是移动构造函数与右值赋值运算符重载呢？

int main ( )
{
    shared_ptr<Test> sp1(new Test);
    cout << "sp1	use_count() = " << sp1.use_count() << endl<<endl;

    shared_ptr<Test> sp2(move(sp1));
    cout << "sp1	use_count() = " << sp1.use_count() <<"  ptr= "<<sp1.get()<< endl;
    cout << "sp2	use_count() = " << sp2.use_count() <<"  ptr= "<<sp2.get()<< endl<<endl;

    shared_ptr<Test> sp3;
    sp3 = move(sp2);
    cout << "sp2	use_count() = " << sp2.use_count() <<"  ptr= "<<sp2.get()<< endl;
    cout << "sp3	use_count() = " << sp3.use_count() <<"  ptr= "<<sp3.get()<< endl<<endl;
}

运行结果：

Test start...
sp1     use_count() = 1

sp1     use_count() = 0  ptr= 0
sp2     use_count() = 1  ptr= 0x1ed7a6a18e0

sp2     use_count() = 0  ptr= 0
sp3     use_count() = 1  ptr= 0x1ed7a6a18e0

Test end...

可以看出，对于移动构造函数与右值赋值运算符重载，引用计数不变，被move的智能指针放弃了对于实际指针的托管。不看源码也能猜到，是在shared_ptr自定义的移动构造函数与右值赋值运算符重载函数中做的事情。
看到这里可能会发现，漏掉了一个关键的函数：release()。实际上，在shared_ptr中没有实现release函数，为什么呢？release函数所做的事情是：转移被托管的指针。转移给谁了不确定，可能是另一个shared_ptr对象，也可能是裸指针。这就不太好控制引用计数了。
引用计数总结如下：
（1）构造shared_ptr对象时，传入一个非空指针，引用计数初始化=1；
（2）根据已有的shared_ptr对象进行拷贝构造、赋值操作的时候，引用计数+1；
（3）当shared_ptr转而管理其他指针时（一般通过reset函数），或者直接置为nullptr时，引用计数-1；
（4）根据已有shared_ptr对象（代号a）的右值进行移动构造函、右值赋值的时候，对象a托管的指针置为空指针，原来的指针的引用计数不变。

三、引用计数的实现原理

在古早版本的java语言中，采用引用计数法进行垃圾回收，基本原理和shared_ptr类似，但是不一样的地方在于，java语言中的计数是放在每个对象里面，有jvm维护一个用户不可感知的计数变量。由于C++语言历史包袱过于沉重，很难从编译器层面做出改变，shared_ptr实际上是编码层面的设计，由shared_ptr对象维护计数变量。
初学者容易产生误解，这个计数变量应该是静态变量？当然不可能是静态变量，因为一个实例化后的shared_ptr可能指向多个指针，不可能统一计数。
它的做法非常简单，shared_ptr对象维护一个被托管指针的同时，维护一个int指针，记录被托管指针被引用的次数。如果有多个shared_ptr托管这个指针的时候，他们都可以修改这个int值（因为是指针），修改之后也可以被其他对象感知到。
（1）通过有参构造函数初始化的时候，给指针变量赋初值，初始化记录引用次数的int指针。
（2）根据shared_ptr A，进行拷贝构造的时候，构造shared_ptr B，B记录的被托管指针赋值为A所记录的，同时，B的计数指针被赋值为A的计数指针，并且指针指向的int值加一。
（3）赋值运算符重载操作同上，但是注意一点，如果判断A和B托管的指针是同一个，函数立刻终止。如果不是同一个，A的托管的原指针对应的计数-1，如果减一后等于0，触发析构函数。
（4）根据shared_ptr A，进行移动构造的时候，构造shared_ptr B，B记录的被托管指针赋值为A所记录的，同时，B的计数指针被赋值为A的计数指针。之后A托管的指针置为null，A记录的引用计数指针也置为null。右值赋值同理。
（5）当shared_ptr A调用reset重置的时候，放弃原来被托管指针，原引用计数-1，如果减一后=0，触发析构函数。置为nullptr同理。
上述方案，其实是虚假的引用计数法，与java的引用计数法完全不能相提并论，有一个非常非常致命的缺陷，后面会提到。

四、自己实现shared_ptr。

template<typename Ty>     //Ty是被托管的指针类型
class my_shared_ptr{
private:
    Ty * ty;     //被托管的指针
    int * count;
    void release(){
        (*count)--;
        if((*count)==0)
        {
            if(ty)
            {
                delete ty;
                ty=NULL;
            }
            if(count)
            {
                delete count;
                count=NULL;
            }
        }
    }
public:
    explicit my_shared_ptr(Ty * ty1=0):ty(ty1){
        if(ty!= nullptr){
            count = new int(1);
        }
    }

    ~my_shared_ptr(){  //析构函数中释放资源
        (*count)--;
        if((*count)==0)
        {
            if(ty)
            {
                delete ty;
                ty=NULL;
            }
            if(count)
            {
                delete count;
                count=NULL;
            }
        }
    }

    Ty * get(){          //返回被托管的指针
        return ty;
    }

    void reset(Ty * ty2){      //重置被托管的指针
        if(ty!=ty2){
            release();
            ty=ty2;
            if(ty!= nullptr){
                count = new int(1);
            }
        }
    }

    Ty * operator ->(){       //重载->和*运算符，让智能指针用起来像指针
        return ty;
    }

    Ty & operator * (){
        return *(ty);
    }

    my_shared_ptr(my_shared_ptr && ty1){     //移动构造函数
        release();
        ty = ty1.ty;
        count = ty1.count;
        ty1.ty= nullptr;
        ty1.count = nullptr;
    }

    my_shared_ptr& operator = (my_shared_ptr && ty1 ){   //移动赋值运算符重载
        release();
        ty = ty1.ty;
        count = ty1.count;
        ty1.ty= nullptr;
        ty1.count = nullptr;
        return *this;
    }

    my_shared_ptr& operator = (my_shared_ptr & ty1 ) {  //左值赋值运算符重载
        release();
        ty = ty1.ty;
        count = ty1.count;
        (*count)++;
        return *this;
    }

    my_shared_ptr(my_shared_ptr & ty1) {   //左值拷贝构造函数
        ty = ty1.ty;
        count = ty1.count;
        (*count)++;
    }
};

五、shared_ptr作为形参

前文提到了，auto_ptr作为形参是一件非常危险的事情，因为其资源转移的特点，会导致访问非法内存。shared_ptr不用考虑这个，看代码：

void my_ptr_test(shared_ptr<Test> ptr) {
    cout<<"when call my_ptr_test, use_count = "<<ptr.use_count()<<endl;
}

int main ( )
{
    shared_ptr<Test> test(new Test);
    cout<<"before call my_ptr_test, use_count = "<<test.use_count()<<endl;
    my_ptr_test(test);
    cout<<"after call my_ptr_test, use_count = "<<test.use_count()<<endl;
}

运行结果：

Test start...
before call my_ptr_test, use_count = 1
when call my_ptr_test, use_count = 2
after call my_ptr_test, use_count = 1
Test end...

显然，赋值给形参以后，仍然出现了引用计数+1，但是函数执行完毕，形参销毁，引用计数-1.所以这个过程程序员完全可以不care，编译器已经帮我们处理好了。

六、shared_ptr的缺陷

（1）循环引用导致无法释放内存

class Girl;

class Boy {
public:
    Boy() {
        cout << "Boy Start" << endl;
    }

    ~Boy() {
        cout << "~Boy End" << endl;
    }

    void setGirlFriend(shared_ptr<Girl> _girlFriend) {
        this->girlFriend = _girlFriend;
    }

private:
    shared_ptr<Girl> girlFriend;
};

class Girl {
public:
    Girl() {
        cout << "Girl Start" << endl;
    }

    ~Girl() {
        cout << "~Girl End" << endl;
    }

    void setBoyFriend(shared_ptr<Boy> _boyFriend) {
        this->boyFriend = _boyFriend;
    }

private:
    shared_ptr<Boy> boyFriend;
};


void useTrap() {
    shared_ptr<Boy> spBoy(new Boy());
    shared_ptr<Girl> spGirl(new Girl());

    // 陷阱用法
    spBoy->setGirlFriend(spGirl);
    spGirl->setBoyFriend(spBoy);
    // 此时boy和girl的引用计数都是2
}


int main(void) {
    useTrap();
    return 0;
}

可以使用weak_ptr解决这个问题。下一篇博客有详细介绍。

（2）多次释放内存
循环引用是引用计数法的自身缺陷，所以在现在版本的jvm中已经抛弃了这种垃圾回收机制。但是多次释放内存完全是shared_ptr的设计缺陷，因此，shared_ptr使用的引用计数法是虚假的引用计数法。

int main(void) {
    Test * test = new Test;
    shared_ptr<Test> ptr1(test);
    shared_ptr<Test> ptr2(test);
}

运行结果：

Test start...
Test end...
Test end...

进程已结束,退出代码-1073740940 (0xC0000374)

为什么程序会崩溃？因为一个指针被毫不相关的两个shared_ptr托管，它们之间没有拷贝、赋值等关系，所以会各自引用计数。ptr1析构的时候，看到自身引用计数是1，减为零，然后delete test。ptr2析构的时候，仍然看到自身引用计数是1，再次delete test。注意到第二次test也不是空指针，是一个正常的地址，但是指向的对象已经被delete了，不能再次delete，否则就会引发程序崩溃。
根本原因，shared_ptr的引用计数由智能指针管理，正常应该由堆上的对象管理。
那该怎么办呢？最好的办法，如第一章所讲，使用make_shared方法初始化智能指针对象。

int main(void) {
    shared_ptr<Test> ptr1 = make_shared<Test>();
    shared_ptr<Test> ptr2 = make_shared<Test>();
}

简单地说，就是不要手动管理指针，这样一来就会避免一个指针被托管给多个毫不相关的shared_ptr。