C++ Primer 学习笔记_56_STL剖析（十一）（原boost库）：详解智能指针（unique_ptr（原scoped_ptr） 、shared_ptr 、weak_ptr源码分析）

智能指针是利用RAII（Resource Acquisition Is Initialization：资源获取即初始化）来管理资源。关于RAII的讨论可以参考前面的《40_面向对象编程--虚函数与多态（六）》。在使用boost库之前应该先下载后放在某个路径，并在VS 包含目录中添加。下面是boost库里面的智能指针：

二、unique_ptr<T>（原来scoped_ptr<T>）

1、示例

#include <iostream>
#include <memory>
using namespace std;

class X
{
public:
    X()
    {
        cout << "X ..." << endl;
    }
    ~X()
    {
        cout << "~X ..." << endl;
    }
};

int main(void)
{
    cout << "Entering main ..." << endl;
    {
        unique_ptr<X> pp(new X);

        //boost::unique_ptr<X> p2(pp); //Error:所有权不能转移
    }
    cout << "Exiting main ..." << endl;

    return 0;
}

2、源码分析

来稍微看一下scoped_ptr的简单定义：

namespace boost
{

    template<typename T> class scoped_ptr : noncopyable
    {
    private:

        T *px;

        scoped_ptr(scoped_ptr const &);
        scoped_ptr &operator=(scoped_ptr const &);

        typedef scoped_ptr<T> this_type;

        void operator==( scoped_ptr const & ) const;
        void operator!=( scoped_ptr const & ) const;
    public:
        explicit scoped_ptr(T *p = 0);
        ~scoped_ptr();

        explicit scoped_ptr( std::auto_ptr<T> p ): px( p.release() );
        void reset(T *p = 0);

        T &operator*() const;
        T *operator->() const;
        T *get() const;

        void swap(scoped_ptr &b);
    };

    template<typename T>
    void swap(scoped_ptr<T> &a, scoped_ptr<T> &b);
}

typedef scoped_ptr<T> this_type;  当调用pp.reset()，reset 函数构造一个临时对象，它的成员px=0， 在swap 函数中调换 pp.px  与 (this_type)(p).px， 即现在pp.px = 0; //解绑临时对象接管了裸指针（即所有权可以交换），reset 函数返回，栈上的临时对象析构，调用析构函数，进而delete px;

另外拷贝构造函数和operator= 都声明为私有，故所有权不能转移，且因为容器的push_back 函数需要调用拷贝构造函数，故也不能将scoped_ptr 放进vector，这点与auto_ptr 相同（不能共享所有权）。此外，还可以使用 auto_ptr 对象 构造一个scoped_ptr 对象：scoped_ptr( std::auto_ptr<T> p ): px( p.release() );

1、示例

#include <iostream>
#include <memory>
using namespace std;

class X
{
public:
    X()
    {
        cout << "X ..." << endl;
    }
    ~X()
    {
        cout << "~X ..." << endl;
    }
};

int main(void)
{
    cout << "Entering main ..." << endl;
    shared_ptr<X> p1(new X);
    cout << p1.use_count() << endl;
    shared_ptr<X> p2 = p1;
    //boost::shared_ptr<X> p3;
    //p3 = p1;

    cout << p2.use_count() << endl;
    p1.reset();
    cout << p2.use_count() << endl;
    p2.reset();
    cout << "Exiting main ..." << endl;
    return 0;
}

#include <iostream>
#include <memory>
#include <vector>
using namespace std;

class X
{
public:
    X()
    {
        cout << "X ..." << endl;
    }
    ~X()
    {
        cout << "~X ..." << endl;
    }
};

int main(void)
{
    vector<auto_ptr<X> > v;
    auto_ptr<X> p(new X);
    //v.push_back(p);  //Error:auto_ptr调用了=运算符，而push_back传入是const参数，因此不能调用push_back

    vector<shared_ptr<X> > v2;
    shared_ptr<X> p2(new X);
    v2.push_back(p2);
    cout << p2.use_count() << endl;

    return 0;
}

void f(shared_ptr<int>, int);
int g();

void ok()
{
    shared_ptr<int> p(new int(2));
    f(p, g());
}

void bad()
{
    f(shared_ptr<int>(new int(2)), g());
}

强引用与弱引用：

（1）强引用，只要有一个引用存在，对象就不能释放

（2）弱引用，并不增加对象的引用计数（实际上是不增加use_count_， 会增加weak_count_）；但它能知道对象是否存在

【1】如果存在，提升为shared_ptr(强引用）成功
【2】如果不存在，提升失败

（3）通过weak_ptr访问对象的成员的时候，要提升为shared_ptr