在C++中，动态内存是的管理是通过一对运算符来完成的：new  ，在动态内存中为对象分配空间并返回一个指向该对象的指针，delete接受一个动态对象的指针，销毁该对象，并释放该对象关联的内存。

动态内存的使用很容器出现错误，确保在正确的时间释放动态内存是极其困难的。有时候我们会忘记释放动态内存，这样就会造成内存泄露；或者是一个对象还没有使用完，就释放了它所关联的内存，再去使用它，就会造成难以预估的错误。

因此，为了更好地管理使用动态内存，C++11新标准提供了两种智能指针：shared_ptr和unique_ptr来管理动态对象。它们负责自动释放所管理的内存，shared_ptr允许多个指针同时指向同一个动态对象，unique_ptr则独占所指向的资源。标准库还定义了一个weak_ptr，它是一种弱引用，指向shared_ptr所管理的对象，但不增加shared_ptr的引用计数。三个类型都定义在 <memory>头文件中



shared_ptr类


智能指针也是模板，所以在创建一个shared_ptr类时，必须指出指针指向的对象的类型：
shared_ptr<string> p1; // 指向string类型的指针
shared_ptr<int> p2;    // 指向int类型的指针

默认初始化的智能指针保存着一个空指针。
下面是shared_ptr和unique_ptr都支持的操作：

shared_ptr和unique_ptr都支持的操作
shared_ptr<T> sp 空智能指针，可以指向类型为T的对象
unique_ptr<T> up  
p 将p作为一个判断条件，若p指向一个对象，则为true
*p 解引用p，获得它指向的对象
p->mem 等价于(*p).mem
p.get() 返回p中保存的指针
swap(p, q) 交换p和q中的指针
p.swap(q)  

下面是shared_ptr独有的操作：

shared_ptr独有的操作
make_shared<T>(args) 返回一个shared_ptr，指向一个动态分配的类型为T的对象。使用args初始化此对象
shared_ptr<T>p(q) p是shared_ptr q的拷贝，此操作会递增q中的计数器，q中的指针必须能转换为T*
p = q p和q都是shared_ptr，所保存的指针必须能相互转换，此操作会递减p的引用计数，递增q的引用计数，若p的引用计数变为0，则将其管理的原内存释放。
p.unique() 若p.use_count()为1，返回true，否则返回false
p.use_count() 返回与p共享对象的智能指针数量，可能很慢，主要用于调试



 

  • make_shared函数
make_shared也定义在 <memory>中。 当要使用make_shared时，必须指定想要创建的对象的类型。
// p3指向一个为1的int类型的shared_ptr
shared_ptr<int> p3 = make_shared<int>(1); 

// p4指向一个值为"9999999999"的string类型的shared_ptr
shared_ptr<string> p3 = make_shared<string>(10, '9'); 

// p5指向一个值初始化的int，即，值为0
shared_ptr<int> p5 = make_shared<int>();

make_shared用参数来构造给定类型的对象，例如，make_shared<string>的参数必须与string的某个构造函数的参数匹配，make_shared<int>的参数必须能初始化一个int。

 

如果我们不给make_shared传递任何参数，对象就会进行值初始化。


 

  • shared_ptr的拷贝和赋值
当进行拷贝或辅助时， 每个shared_ptr都会记录有多少个其他shared_ptr指向相同的对象:
auto p = make_shared<int>(1); // p指向的对象只有p一个引用者
auto q(p); // p和q指向相同对象，此对象有两个引用者

每个shared_ptr都有一个关联的计数器，叫做引用计数，无论何时拷贝一个shared_ptr，计数器都会递增，包括赋值，值传递的参数传递，作为返回值；当我们赋予shared_ptr
一个新值，或者它被销毁，比如一个shared_ptr离开所在作用域，计数器就会递减。当一个shared_ptr的计数器为0时，他就会自动释放所管理的对象。

 

auto r= make_shared_ptr<int>(42); // r指向的int只有一个引用者
r = q;    // 给r赋值，令它指向新对象
          // 递增q指向的对象的引用计数
          // 递减r指向的对象的引用计数
          // r原来指向的对象已经没有引用者，会自动释放


  • shared_ptr自动销毁所管理的对象......
当指向一个对象的最后一个shared_ptr被销毁时，shared_ptr类会自动销毁此对象，它是通过自己的析构函数来完成销毁工作的。shared_ptr的析构函数会递减它所指向的对象的引用计数，如果引用计数变为0，shared_ptr的析构函数就会销毁对象，并释放它所占内存。

 

 

  • ......shared_ptr还会自动释放相关联的内存
当动态对象不再被使用时，shared_ptr类会自动释放对象。例如，我们有这样一个函数，返回一个shared_ptr，指向一个Foo类型的动态分配的对象，对象是通过一个类型为T的参数进行初始化的：
shared_ptr<Foo> factory(T arg) {
    // do some thing
    // ...
    return make_shared<Foo>(arg);
}

由于factory返回一个shared_ptr，所以我们可以确保它分配的对象会在恰当的时刻被释放。例如，我们可以将一个shared_ptr保存在局部变量中：
void use_factory(T arg) {
    shared_ptr<Foo> p = factory(arg);
    // 使用p
    // p离开了作用域，它指向的内存被自动释放
}

p是use_factory的局部变量，在函数结束时它被销毁。在p被销毁时，会递减引用计数并检查是否为0。在此例中，p是唯一引用factory返回的内存的对象，由于p将要销毁，p指向的这个对象也被销毁，所占的内存也被释放。
但如果有其他shared_ptr也指向这块内存，它就不会被释放：

 

void use_factory(T arg) {
    shared_ptr<Foo> p = factory(arg);
    // 使用p
    return p; // 会拷贝p的一份实例，p的引用计数递增
}


这一次，use_factory在结束时，p被销毁，它指向的内存还有其他使用者，shared_ptr保证只要有任何shared_ptr对象引用它，它就不会被释放掉。

如果将一个shared_ptr存放于一个容器中，而后不再需要全部元素，而只使用其中一部分，要记得erase删除不再需要的那些元素