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 destroyed5、PIMPL
问题原因：嵌套了多重头文件，编译速度降低；因为类Y中有X的对象，这样如果X类改变，所有Y的对象都需要重新编译，因为此时类Y的大小已经改变，这样客户程序就不仅仅依赖于接口，还依赖于库里面的具体实现。
解决方法：将包含头文件改成声明类；将对象改成指针（32位的4个字节，64位8个字节，这是不会变化的）
如果一定要使用到类的对象的话，那就把类的对象都抽象到同一个类Impl中，然后通过Impl的指针来访问
class Y
{
Impl P;
};
class Impl
{
A a;
B b;
C c;
};
