第21课 shared_ptr共享型智能指针

一. shared_ptr的基本用法

（一）与unique_ptr的比较

比较	shared_ptr	unique_ptr	备注
初始化	①shared_ptr<T> sp;   sp.reset(new T()); ②shared_ptr<T> sp(new T()); ③shared_ptr<T> sp1 = sp; //拷贝构造 ④auto sp = make_shared<int>(10);	①unique_ptr<T> up;   up.reset(new T()); ②unique_ptr<T> up(new T()); ③unique_ptr<T> up1 = std::move(up);//移动构造 ④auto up = make_unique<int>(10);	两者的构造函数将声明为explicit，即不允许隐式类型转换，如shared_ptr<int> sp = new int(10);
条件判断	如，if(sp){…}	如，if(up){…}	两都均重载operator bool()
解引用	*sp	*up	解引用，获得它所指向的对象
->mem	sp->mem	up->mem	重载->运算符
get()	sp.get()	up.get()	返回智能指针中保存的裸指针，要小心使用。
p.swap(q)	sp.swap(q);	up.swap(q);	交换p和q指针
独有操作	①shared_ptr<T> p(q);//拷贝构造 ②p = q;//赋值 ③p.unique();若p.use_count()为1，返回true,否则返回false。 ④p.use_count()//返回强引用计数	①up=nullptr;释放up指向的对象，并将up置空。 ②up.release();//up放弃对指针的控制权，返回裸指针，并将up置空 ③up.reset();释放up指向的对象。   up.reset(q);其中q为裸指针。令up指向q所指对象。   up.reset(nullptr);置空	注意: ①unique_ptr不可拷贝和赋值，但可以被移动。 ②release会切断unique_ptr和它原来管理的对象间的联系。通常用来初始化另一个智能指针。

（二）指定删除器

　　1. shared_ptr<T> sp1(q, deleter1);与unique_ptr不同，删除器不是shared_ptr类型的组成部分。假设，shared_ptr<T> sp2(q,deleter2)，尽管sp1和sp2有着不同的删除器，但两者的类型是一致的，都可以被放入vector<shared_ptr<T>>类型的同一容器里。

　　2. 与std::unique_ptr不同，自定义删除器不会改变std::shared_ptr的大小。其始终是祼指针大小的两倍。

　　3. 当使用shared_ptr管理动态数组时，需要指定删除器。因为默认删除器不支持数组对象。如shared_ptr<int> sp(new int[10], std::default_delete<int[]>);

　　4. 删除器可以是普通函数、函数对象和lambda表达式等。默认的删除器为std::default_delete，其内部是通过delete来实现功能的。

二. 剖析std::shared_ptr

（一）std::shared_ptr的内存模型

 

　　1. shared_ptr包含了一个指向对象的指针和一个指向控制块的指针。每一个由std::shared_ptr管理的对象都有一个控制块，它除了包含引用计数之外，还包含了自定义删除器的副本和分配器的副本以及其他附加数据。

　　2. 控制块的创建规则：

　　（1）std::make_shared总是创建一个控制块。

　　（2）从具备所有权的指针出发构造一个std::shared_ptr时，会创建一个控制块。（如std::unique_ptr转为shared_ptr时会创建控制块，因为unique_ptr本身不使用控制块，同时unique_ptr置空）

　　（3）当std::shared_ptr构造函数使用裸指针作为实参时，会创建一个控制块。这意味从同一个裸指针出发来构造不止一个std::shared_ptr时会创建多重的控制块，也意味着对象会被析构多次。如果想从一个己经拥有控制块的对象出发创建一个std::shared_ptr，可以传递一个shared_ptr或weak_ptr而非裸指针作为构造函数的实参，这样则不会创建新的控制块。

【经验】

　　①尽可能避免将裸指针传递给一个std::shared_ptr的构造函数，常用的替代手法是使用std::make_shared。

　　②如果必须将一个裸指针传递给shared_ptr的构造函数，就直接传递new运算符的结果，而非传递一个裸指针变量。如shared_ptr<Widget> spw (new Widget, logginDel);

　　③不要将this指针返回给shared_ptr。当希望将this指针托管给shared_ptr时，类需要继承自std::enable_shared_from_this，并且从shared_from_this()中获得shared_ptr指针。（具体见《enable_shared_from_this》部分的分析）

　　3. 引用计数（强引用计数）

　　（1）shared_ptr的构造函数会使该引用计数递增，而析构函数会使该计数递减。但移动构造时表示从一个己有的shared_ptr移动构造到一个新的shared_ptr。这意味着一旦新的shared_ptr产生后，原有的shared_ptr会被置空，其结果是引用计数没有变化。

　　（2）复制赋值同时执行两种操作（如sp1 和sp2是指向不同对象的shared_ptr，则sp1 = sp2时，将修改sp1使得其指向sp2所指的对象。而最初sp1所指向的对象的引用计数递减，同时sp2所指向的对象引用计数递增）

　　（3）reset函数，如果不带参数时，则引用计数减1。如果不带参数时，如sp.reset(p)则sp原来指向的对象引用计数减1，同时sp指向新的对象(p)

　　（4）如果实施一次递减后最后的引用计数变成0，即不再有shared_ptr指向该对象，则会被shared_ptr析构掉。

　　（5）引用计数的递增和递减是原子操作，即允许不同线程并发改变引用计数。

【编程实验】shared_ptr的陷阱分析

#include <iostream>
#include <vector>
#include <memory> // for smart pointer

using namespace std;

class Widget{};

void func(shared_ptr<Widget> sp){}

int funcException() { /*throw 1;*/ return 0; } //假设该函数会抛出异常

void demo(shared_ptr<int> sp, int f){}

int main()
{
    //1. 陷阱：用同一裸指针创建多个shared_ptr
    //1.1 错误做法
    auto pw = new Widget;
    std::shared_ptr<Widget> spw1(pw); //强引用计数为1，为pw创建一个控制块
    //std::shared_ptr<Widget> spw2(pw); //强引用计数为1，为pw创建另一个新的控制块，会导致多次析构

    auto sp = new Widget;
    func(shared_ptr<Widget>(sp)); //慎用裸指针，sp将在func结束后被释放！

    //1.2 正确做法
    std::shared_ptr<Widget> spw3(spw1); //ok，pw的强引用计数为2。使用与spw1同一个控制块。
    std::shared_ptr<Widget> spw4(new Widget); //将new的结果直接传递给shared_ptr
    std::shared_ptr<Widget> spw5 = std::make_shared<Widget>(); //强烈推荐的做法!
    
    //2. 陷阱：在函数实参中创建shared_ptr
    //2.1 shared_ptr与异常安全问题
    //由于参数的计算顺序因编译器和调用约定而异。假定按如下顺序计算
    //A.先前new int，然后funcException();
    //B.假设恰好此时funcException产生异常。
    //C.因异常出现shared_ptr还来不及创建，于是int内存泄露
    demo(shared_ptr<int>(new int(100)), funcException());

    //2.2 正确做法
    auto p1 = std::make_shared<int>(100);
    demo(p1, funcException());

    //3. 陷阱：shared_ptr的循环引用（应避免）（见第22课 weak_ptr）

    //4. 删除器
    auto deleter1 = [](Widget* pw) {cout << "deleter1"<< endl; delete pw; };
    auto deleter2 = [](Widget* pw) {cout << "deleter2"<< endl; delete pw; };

    std::shared_ptr<Widget> pw1(new Widget, deleter1);
    std::shared_ptr<Widget> pw2(new Widget, deleter2);

    std::shared_ptr<Widget> pw3(pw1);
    pw3.reset(new Widget); //deleter恢复为默认的std::default_delete

    vector<std::shared_ptr<Widget>> vecs;
    vecs.emplace_back(pw1);
    vecs.emplace_back(pw2); //pw1和pw2虽然有不同的删除器，但类型相同，可以放入同一容器内。

    //5. 其它
    //5.1 shared_ptr的大小
    cout << sizeof(spw1) << endl;//8
    cout << sizeof(pw1) << endl; //8
    //5.2 shared_ptr管理动态数组（建议用std::array、std::vector取代）
    std::shared_ptr<int> pArray1(new int[10], [](int* p) {delete[] p; }); //使用delete[]
    std::shared_ptr<int> pArray2(new int[10], std::default_delete<int[]>()); //使用default_delete<int[]>()
    //5.3 常见操作
    cout << pw1.use_count() << endl; //2

    if (pw1) //pw1.use_count >= 1 ?
    {
        cout << "pw1.use_count >= 1" << endl;
    }
    else
    {
        cout << "pw1.use_count == 0" << endl;
    }
    //5.4 别名构造
    int* p = new int(10);

    std::shared_ptr<int> a(new int(20));
    std::shared_ptr<int> b(a, p);  // alias constructor: co-owns a, points to p。可用于多继承中
                                   // a 和 b拥用相同的控制块，但两者指向的对象不同。由于两者拥用相同的
                                   //的控制块，可认为a和b所指对象具有相同的拥有者，因此10和20两个堆对象
                                   //拥有相同的生命期
    cout << *a << endl; //20
    cout << *b << endl; //10

    return 0;
}

四. enable_shared_from_this模板的分析

（一）模板分析（以boost::enable_shared_from_this为例）

template<class T> class enable_shared_from_this
{
protected:

    enable_shared_from_this() BOOST_NOEXCEPT
    {
    }

    enable_shared_from_this(enable_shared_from_this const &) BOOST_NOEXCEPT
    {
    }

    enable_shared_from_this & operator=(enable_shared_from_this const &) BOOST_NOEXCEPT
    {
        return *this;
    }

    ~enable_shared_from_this() BOOST_NOEXCEPT // ~weak_ptr<T> newer throws, so this call also must not throw
    {
    }

public:

    shared_ptr<T> shared_from_this()
    {
        shared_ptr<T> p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }

    shared_ptr<T const> shared_from_this() const
    {
        shared_ptr<T const> p( weak_this_ );
        BOOST_ASSERT( p.get() == this );
        return p;
    }

public: // actually private, but avoids compiler template friendship issues

    // Note: invoked automatically by shared_ptr; do not call
    template<class X, class Y> void _internal_accept_owner( shared_ptr<X> const * ppx, Y * py ) const
    {
        if( weak_this_.expired() )
        {
            weak_this_ = shared_ptr<T>( *ppx, py );
        }
    }

private:

    mutable weak_ptr<T> weak_this_;
};

boost::enable_shared_from_this