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);  // 1child_ptr child(new Child);     // 1parent->child_ = child;            // 1child->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_ptrif (!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;
};