使用boost的智能指针需要包含头文件"boost/smart_ptr.hpp"，c++11中需要包含头文件<memory>
1、auto_ptr、scoped_ptr、scoped_array
①、auto_ptr是C++标准中的智能指针，在指针退出作用域的时候自动释放指针指向的内存，即使是异常退出的时候。auto_ptr实际上是一个对象，重载了operator*和operator->，且提供了一些成员函数，比如使用成员get()可以获得对应类型的原始指针。
auto_pt的特点是可以对其进行复制和赋值，但同一时刻只能有一个auto_ptr管理指针。
使用之前需要包含头文件<memory>，eg:
#include <memory> #include <cassert> int main() { std::auto_ptr<int> ap1(new int(5)); cout << *ap1 << endl; int* p = ap1.get(); cout << *p << endl; std::auto_ptr<int> ap2(ap1);//ap1失去管理权，不再拥有指针，ap2得到管理权 assert(ap1.get() == 0);//get()获得的指针为空 return 0; }
②、boost的scoped_ptr用法类似于auto_ptr，都不能用作容器的元素，不支持++、--等指针算数操作。
scoped_ptr的特点是拷贝构造函数和赋值操作符都是私有的，所以scoped_ptr不能进行复制和赋值操作，保证了对对象的唯一管理权。
#include "boost/smart_ptr.hpp" int main() { boost::scoped_ptr<int> sp1(new int(10)); boost::scoped_ptr<int> sp2(sp1);//编译无法通过：不能转让sp1的管理权到sp2 boost::scoped_ptr<int> sp3(new int(30)); sp3 = sp1;//编译无法通过：不能转让sp1的管理权到sp3 return 0; }
③、如果需要指向new[]开辟的内存数组，应该使用scoped_array而不是scoped_ptr。scoped_array构造函数的参数必须是new[]返回的指针，支持使用[]来访问元素，但不支持*、->运算符。scoped_array也不支持拷贝，赋值。
2、shared_ptr、shared_array、weak_ptr
①、概述
shared_ptr没有scoped_ptr的限制，它可以被自由的拷贝和赋值，也可以作为容器的元素。它是一种引用计数型的智能指针，当没有代码使用它时，即引用计数为0的时候自动删除动态分配的内存。
shared_ptr也支持*和->操作符，支持==比较操作(相当于a.get() == b.get())，提供隐式bool类型转换以判断指针的有效性，同样不提供指针的算数运算。
shared_ptr中的一些成员函数：
get()：获取内部原始指针。
reset()：重置shared_ptr，会导致引用计数减1。不带参数的reset()将shared_ptr重置为不指向任何对象，带参数的reset()用来将shared_ptr重置为指向新的对象。
unique()：用来检测当前是不是指针的唯一管理者，即引用计数为1。
use_count()：用来获取当前引用计数，但它一般在调试中使用，因为其效率很低，如果只是判断当前引用计数是否为1的话可以使用unique()来替换它。
将shared_ptr赋值为nullptr相当于调用reset()。
shared_ptr也提供了转换运算符dynamic_pointer_cast<>、static_pointer_cast<>、const_pointer_cast<>。
使用示例1：
#include "boost/smart_ptr.hpp" int main() { boost::shared_ptr<int> spInt(new int(10)); if (spInt) //true { spInt.reset(); if (spInt) //false ; } boost::shared_ptr<int> spInt1(new int(5)); //指针引用计数加1，现为1 assert(spInt1.unique()); boost::shared_ptr<int> spInt2(spInt1); //指针的引用计数加1，现为2 boost::shared_ptr<int> spInt3; assert(!spInt3); spInt3 = spInt1; //指针的引用计数加1，现为3 spInt3.reset(); //spInt3被重置，指针的引用计数减1，现为2 assert(!spInt3); return 0; //spInt2退出作用域，指针引用计数减1，为1， spInt1退出作用域，指针引用计数减1，为0，此时释放内存 }
使用示例2：
class Foo; typedef std::shared_ptr<Foo> SPtr; class Foo { }; void func(SPtr sp) { int cnt = sp.use_count(); cout << cnt << endl; } int main() { func(SPtr(new Foo)); //输出为1 SPtr sp(new Foo); func(sp); //输出为2 return 0; }
②、注意事项
shared_ptr不支持直接使用原始指针进行"="操作：
int*p = new int(0); std::shared_ptr<int> sp(p); //std::shared_ptr<int> sp = p; //error ! //sp = p; //error !
对shared_ptr进行 = 操作后原shared_ptr的引用计数会减1，如果变为0的话就会释放其指向的对象，但原对象的释放是在新对象生成之后，稳妥的方法是=操作之前先进行reset操作：
auto sp = std::make_shared<CFoo>(); sp.reset(); //先使用reset()或= nullptr来释放原对象 sp = std::make_shared<CFoo>();
shared_ptr不能多次引用同一原始指针，否则会产生多次释放错误：
CFoo* p = new CFoo; std::shared_ptr<CFoo> sp(p); std::shared_ptr<CFoo> sp2(p); //error !
shared_ptr不能直接包含对象的this指针，如下所示的代码同样会导致两次释放问题：
class Foo { public: virtual ~Foo() { int a = 0; } std::shared_ptr<Foo> getSharedPtr() { return std::shared_ptr<Foo>(this); } }; int main() { std::shared_ptr<Foo> sp(new Foo); std::shared_ptr<Foo> spT = sp->getSharedPtr(); return 0; }
应该使用shared_from_this，需要注意的两点：shared_from_this()方法不能在当前类的构造函数中调用，如果当前对象由一个unique_ptr控制生命，那么对象内不能使用shared_from_this：
class Foo : public std::enable_shared_from_this<Foo> { public: virtual ~Foo() { int a = 0; } std::shared_ptr<Foo> getSharedPtr() { return shared_from_this(); } }; int main() { std::shared_ptr<Foo> sp(new Foo); std::shared_ptr<Foo> spT = sp->getSharedPtr(); return 0; }
shared_ptr不是线程安全的，它的的线程安全级别和内置类型、容器、string 一样，即：
l 多个线程对不同的shared_ptr写入是线程安全的，即使这些shared_ptr指向同一原始指针。
l 同一个 shared_ptr 可被多个线程同时读取。
l 如果要从多个线程读写同一个 shared_ptr 对象，那么需要加锁。
如下所示：
shared_ptr<Foo> globalPtr; Mutex mutex; void read() { shared_ptr<Foo> ptr; { MutexLock lock(mutex); //RAII Mutex ptr = globalPtr; // read globalPtr } // use ptr since here doit(ptr); } void write() { shared_ptr<Foo> newptr(new Foo); { MutexLock lock(mutex); //RAII Mutex globalPtr = newptr; // write to globalPtr } // use newptr since here doit(newptr); }
应该避免使用临时的shared_ptr对象，对此，boost上的说明是：假设有下面的代码，ok函数是正确的做法，而bad函数有可能会导致内存泄露，因为f函数参数的执行顺序可能是先new int(2)，再执行g()，然后再执行shared_ptr<int>()，假设在g()方法中产生了异常，将不会再执行shared_ptr<int>()，new int(2)的内存泄露。
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()); }
③、工厂函数make_shared
当shared_ptr的构造参数是一个new操作符的时候，虽然我们不用手动调用delete来释放它，可这导致了代码中的某种不对称性，所以应该使用工厂模式来解决：头文件"boost/make_shared.hpp"中提供了一个自由工厂函数make_shared<T>()来消除显示的new操作，它可以返回一个shared_ptr<T>对象，使用示例：
#include "boost/smart_ptr.hpp" #include "boost/make_shared.hpp" #include <vector> int main() { boost::shared_ptr<string> sp = boost::make_shared<string>("make_shared"); boost::shared_ptr<std::vector<int>> spv = boost::make_shared<std::vector<int>>(10, 2); assert(spv->size() == 10); return 0; }
C++11中也提供了std::make_shared<T>()来使用。
④、删除器
shared_ptr默认使用delete释放它指向的对象，我们可以通过使用其另一种构造方法来指定其他的释放操作。
shared_ptr有一种特殊形式的构造函数：shared_ptr(T* p, D d); 这里边的d就是删除器，它可以是一个函数对象或函数指针。删除器用来指定shared_ptr在析构的时候即离开作用域的时候不是执行释放内存的操作，而是执行d函数。函数get_deleter()可以获得删除器指针。
删除器使用示例1：
std::unique_ptr<int> u5 (new int, std::default_delete<int>());
删除器使用示例2：
class CSock { ... }; CSock* open_sock() { CSock* s = new CSock; ...//do some open job return p; } void close_sock(CSock* s) { ...//do some close job delete s; } boost::shared_ptr(CSock*)(open_sock(), close_sock);
删除器使用示例3：
struct Foo { Foo() { std::cout << "Foo... "; } ~Foo() { std::cout << "~Foo... "; } }; struct D { void operator()(Foo* p) const { std::cout << "Call delete from function object... "; delete p; } }; std::shared_ptr<Foo> sh4(new Foo, D()); std::shared_ptr<Foo> sh5(new Foo, [](auto p) { std::cout << "Call delete from lambda... "; delete p; });
删除器使用示例4：
//当shared_ptr离开作用域的时候，自动调用fclose()关闭文件。 shared_ptr<FILE> fp(fopen("./1.txt", "r"), fclose);
⑤、shared_array
使用shared_array来指向使用new[]开辟的数组，它同样使用引用计数机制。
⑥、weak_ptr
我们一般使用一个shared_ptr或weak_ptr来初始化weak_ptr，当使用一个shared_ptr对象来构造weak_ptr的时候不会引起shared_ptr引用计数的增加，即weak_ptr不能控制对象的生命期。
weak_ptr主要用来获悉对象是存在的还是已经被释放了，通过成员函数lock()。lock()可以从被观测的shared_ptr获得一个shared_ptr对象，如果对象存在的话，lock()会导致shared_ptr的引用计数加1，如果对象已经被释放了则lock()返回空的shared_ptr（以默认构造函数构造的shared_ptr，其use_count()为0）。lock()是线程安全的。weak_ptr的expired()方法可以用来判断当前weak_ptr对象是否是空的，当weak_ptr没有观测对象（没有用shared_ptr进行初始化）或者观测对象已经被释放expired()返回true。weak_ptr也有use_count()方法，它获得的是被观测对象（shared_ptr）的引用计数。
boost::weak_ptr<int> wpEmpty; bool b = wpEmpty.expired(); //true boost::shared_ptr<int> sp(new int(10)); boost::weak_ptr<int> wp(sp); b = wp.expired(); //false boost::shared_ptr<int> sp2 = wp.lock(); if (sp2) { assert(wp.use_count() == 2); } sp.reset(); sp2.reset(); b = wp.expired(); //true
当两个shared_ptr互相包含的时候，会导致双方无法释放的问题，比如下面这种情况，当func()返回的时候两个对象都得不到释放，解决方法是使用weak_ptr来代替shared_ptr。
class Child; class Parent { public: ~Parent() { cout << "Parent destruct" << endl; } shared_ptr<Child> m_spChild; }; class Child { public: ~Child() { cout << "Child destruct" << endl; } shared_ptr<Parent> m_spParent; }; void Func() { shared_ptr<Parent> spParent(new Parent); shared_ptr<Child> spChild(new Child); spParent->m_spChild = spChild; spChild->m_spParent = spParent; } int main() { Func(); getchar(); return 0; }
3、unique_ptr
unique_ptr与shared_ptr不同的是只能有一个unique_ptr指向一个对象，因此unique_ptr不支持普通的拷贝或赋值操作（使用工厂函数make_unique<>进行 = 初始化除外）。一般情况下不推荐使用unique_ptr，因为在一些特定的复杂情况下unique_ptr的特性会导致内存不能复制而编译出错：
std::unique_ptr<string> p1(new string("test")); std::unique_ptr<string> p2 = std::make_unique<string>("hello"); p2 = std::make_unique<string>("abc"); p2 = p1; //error std::unique_ptr<string> p3(p1); //error std::unique_ptr<string> p4 = p1; //error
成员方法get()可以获得当前管理对象的指针，release()或reset()将指针的所有权从一个unique_ptr转移到另一个unique_ptr。release()会返回当前保存的指针，而且它仅仅是切断与当前管理对象的关系，并不会释放该对象资源。reset()接收一个新的指针，并将原来管理的对象释放。不能拷贝unique_ptr的规则有一个例外，我们可以拷贝一个将要被销毁的unique_ptr，最常见的例子是从函数返回一个unique_ptr：
std::unique_ptr<string> sp1; sp1.reset(new string); //使用reset初始化 std::unique_ptr<string> sp2; sp2 = std::unique_ptr<string>(new string); //使用临时的unique_ptr赋值 std::unique_ptr<int> clone(int num) { //返回临时unique_ptr return std::unique_ptr<int>(new int(num)); } std::unique_ptr<int> clone(int num) { std::unique_ptr<int> ret(new int(num)); return ret; //返回局部unique_ptr }
当我们使用容器保存unique_ptr的时候应该使用临时的unique_ptr或std::move()：
std::vector<std::unique_ptr<int>> vc; //使用临时的unique_ptr vc.push_back(std::make_unique<int>(100)); //使用std::move() std::unique_ptr<int> up = std::make_unique<int>(100); vc.push_back(std::move(up));
类似shared_ptr，unique_ptr也可以指定删除器，但它与管理删除器的方式与shared_ptr有所不同。