C++之boost智能指针

1、boost智能指针

资源获取即初始化：在构造函数中对资源进行初始化，在析构函数中释放。

智能指针的本质思想是：将堆对象的生存期，用栈对象来管理。这个栈对象就是智能指针。

当new 一个堆对象的时候，立刻用智能指针来接管，

具体做法是：在构造函数进行初始化（用一个指针指向堆对象），在析构函数中调用delete来释放堆对象。

由于智能指针本身是一个栈对象，它的作用域结束的时候，自动调用析构函数，从而调用了delete释放了堆对象。

2、scoped_ptr<T>

#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace std;

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

int main() {
    cout << "entering main ..." << endl;
    {
        // 将p放在这个{}中，出了这个{}，作用域就消失了
        boost::scoped_ptr<X> p(new X);
        // 既不能被拷贝，也不能被赋值(下面这样编译报错，因为在scoped_ptr里里面，拷贝构造和=运算符都是声明成私有的)
        // boost::scoped_ptr<X> p(p);
    }

    std::cout << "Hello, World!" << std::endl;
    return 0;
}

// 输出
entering main ...
X ...
~X ...
Hello, World!

3、share_ptr<T>

如果我们都不调用reset的话，当p1和p2这两个栈上的变量也会自动销毁，销毁的时候也会自动去调用reset。

为什么说shared_ptr是线程安全的？因为在做加法的时候，是一个原子操作BOOST_INTERLOCKED_INCREMENT。

#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/shared_ptr.hpp>
using namespace std;

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

int main() {
    cout << "entering main ..." << endl;

    boost::shared_ptr<X> p1(new X);
    cout << p1.use_count() << endl;

    boost::shared_ptr<X> p2(p1);
    cout << p2.use_count() << endl;

    boost::shared_ptr<X> p3;
    p3 = p1;
    cout << p2.use_count() << endl;

    p1.reset();
    cout << p2.use_count() << endl;

    p2.reset();
    cout << p2.use_count() << endl;

    std::cout << "exiting main ..." << std::endl;
    return 0;
}

// 输出
entering main ...
X ...
1
2
3
2
0
exiting main ...
~X ...

share_ptr<T>注意事项

循环引用（这样的情况下，销毁的时候内部放入引用还都是1，所以不会调用析构函数）

解决方案：手动将引用减一

#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/shared_ptr.hpp>
using namespace std;

class Child;
class Parent;
typedef boost::shared_ptr<Parent> parent_ptr;
typedef boost::shared_ptr<Child> child_ptr;

class Child
{
public:
    Child()
    {
        cout << "Child ..." << endl;
    }
    ~Child()
    {
        cout << "~Child ..." << endl;
    }
    parent_ptr parent_;
};

class Parent
{
public:
    Parent()
    {
        cout << "Parent ..." << endl;
    }
    ~Parent()
    {
        cout << "~Parent ..." << endl;
    }
    child_ptr child_;
};

int main() {
    parent_ptr parent(new Parent);
    child_ptr child(new Child);
    parent->child_ = child;
    child->parent_ = parent;

    parent->child_.reset();
    return 0;
}

// 输出
Parent ...
Child ...
~Child ...
~Parent ...

还有一种解决方式，是通过weak_ptr来解决。

4、weak_ptr<T>

#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/shared_ptr.hpp>
using namespace std;

class Child;
class Parent;
typedef boost::shared_ptr<Parent> parent_ptr;
typedef boost::shared_ptr<Child> child_ptr;

class Child
{
public:
    Child()
    {
        cout << "Child ..." << endl;
    }
    ~Child()
    {
        cout << "~Child ..." << endl;
    }
    parent_ptr parent_;
};

class Parent
{
public:
    Parent()
    {
        cout << "Parent ..." << endl;
    }
    ~Parent()
    {
        cout << "~Parent ..." << endl;
    }
    //child_ptr child_;
    boost::weak_ptr<Child> child_;
};

int main() {
    parent_ptr parent(new Parent);  // 1
    child_ptr child(new Child);     // 1
    parent->child_ = child;            // 1
    child->parent_ = parent;           // 2

//    parent->child_.reset();
    return 0;
}

// 输出
Parent ...
Child ...
~Child ...
~Parent ...

通过weak_ptr访问成员的时候，要提升到share_ptr

#include <iostream>
#include <boost/smart_ptr.hpp>
#include <boost/shared_ptr.hpp>
using namespace std;

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

int main() {
    boost::weak_ptr<X> p;
    {
        boost::shared_ptr<X> p2(new X);
        cout << p2.use_count() << endl;
        p = p2;
        cout << p2.use_count() << endl;

        boost::shared_ptr<X> p3 = p.lock();  // lock()表示提升为shared_ptr
        if (!p3)
        {
            cout << "object is destroyed " << endl;
        }
        else
        {
            p3->Fun();
        }
    }

    boost::shared_ptr<X> p4 = p.lock();
    if(!p4)
    {
        cout << "object is destroyed " << endl;
    }
    else
    {
        p4->Fun();
    }

    return 0;
}
// 输出
X ...
1
1
Fun ...
~X ...
object is destroyed

5、PIMPL

问题原因：嵌套了多重头文件，编译速度降低；因为类Y中有X的对象，这样如果X类改变，所有Y的对象都需要重新编译，因为此时类Y的大小已经改变，这样客户程序就不仅仅依赖于接口，还依赖于库里面的具体实现。

解决方法：将包含头文件改成声明类；将对象改成指针（32位的4个字节，64位8个字节，这是不会变化的）

如果一定要使用到类的对象的话，那就把类的对象都抽象到同一个类Impl中，然后通过Impl的指针来访问

class Y
{
    Impl P;
};

class Impl
{
    A a;
    B b;
    C c;
};