文章目录
前言
C++11标准为C++增加了许多新的特性。常用的特性。如：自动类型推导、智能指针、lambda等。这里主要智能指针介绍。
一、智能指针是什么？
智能指针是存储指向动态分配(位于堆)对象指针的类，用于生存期控制，能确保在离开指针所在作用域时，自动正确地销毁动态分配的对象，以防止内存泄漏。
智能指针的实现原理：引用计数技术，每使用1次，内部引用计数+1；每析构1次，内部引用计数-1，当减为0时，删除所指的堆内存。
C++11拥有3种智能指针：std::shared_ptr、std::unique_ptr、std::weak_ptr。
二、基本用法
1.shared_ptr
shared_ptr是共享的智能指针，利用引用技术允许多个shared_ptr指针指向同一个对象。只在最后一个shared_ptr析构时，引用计数为0，内存才会被自动释放。
初始化
可通过构造函数、make_shared辅助函数、reset方法来初始化shared_ptr，如：
//智能指针的初始化方式
shared_ptr<int> p1(new int(10)); //传参构造
shared_ptr<int> p2=p1; //copy构造
shared_ptr<int> p3; //创建空的shared_ptr,不指向任何内存
p3.reset(new int(20)); //reset方法替换p3管理对象指针为传入指针参数
auto p4=make_shared<int>(30); //利用make_shared辅助函数，创建shared_ptr
if(p3)
{ std::cout<<" p3 is not null" <<std::endl; }
else
{ std::cout << "p3 is null" << std::endl; }
注：
如果智能指针中引用计数 >0, reset将导致引用计数-1；
除了通过引用计数，还可以通过智能指针的operator bool 类型操作符，来判断指针所指内容是否为空(未初始化)；
获取原始指针
使用shared_ptr的get方法来获取原始指针。如：
// 智能指针创建方法错误
shared_ptr<int> p1= new int(10);//编译错误，不允许直接将普通指针赋值给智能指针
shared_ptr<int> p1(new int(10));
int* rawp=p.get();
std::cout<< *rawp << std::endl;
注: get获取原始指针不会引起引用技术变化。
指定删除器
智能指针的默认删除器是 operator delete，初始化的时候可指定自定义删除器。如下：
// 自定义删除器 DeleteIntPtr
void DeleteIntPtr(int *p){
delete p;
}
shared_ptr<int> p1(new int, DeleteIntPtr); //指定shared_ptr指定自定义删除器
何时调用 删除器呢？
仅当p的引用计数为0时，自动调用删除器DeleteIntPtr释放对象的内存。删除器可是函数，也可是lambda表达式，也可是任意可调用对象。
//为shared_ptr指定删除器示例
shared_ptr<int> p1(new int, DeleteIntPtr); // 为指向int的shared_ptr指定删除器，删除器时自定义函数
shared_ptr<int> p2(new int, [](int* p){delete p;}); //删除器时lambda表达式
function<void(int*)> f=DeleteIntPtr;
shared_ptr<int> p3(new int, f); //删除函数对象
shared_ptr<int> p4(new int[10], [](int* p) {delete[] p; }); // 为指向数组的shared_ptr指定删除器
shared_ptr<int> p5(new int[10], std::default_delete<int[] >()); //删除器是default_delete
shared_ptr默认删除器是删除delete T 对象的，并不是针对数组。如果要删除数组，就需要为数组指定delete[] 删除器。封装1个make_shared_array方法来让shared_ptr支持数组：
template<typename T>
shared_ptr<T> make_shared_array(size_t size){
return shared_ptr<T>(new T[size], default_delete<T[]>());
}
//使用make_shared_array, 创建指向数组的shared_ptr
shared_ptr<int> p1=make_shared_array<int>(100);
shared_ptr<char> p2= make_shared_array<char> (100);
shared_ptr的坑
1、不要将普通指针赋值给shared_ptr
shared_ptr<int> p1=new int; //编译错误
2、不要将一个原始指针初始化多个shared_ptr
int* rawp=new int;
shared_ptr<int> p1(rawp);
shared+ptr<int> p2(rawp); // 逻辑错误，可能导致程序崩溃
3、不要在函数是实参中创建shard_ptr
void func(shared_ptr<int> p1, int a);
int g();
func(shared_ptr<int> (new int), g()); // 有缺陷
由于C++的函数参数计算顺序在不同的编译器(不同的默认调用惯例)下，可能不一样，一般从右向左，有可能从左向右，因而过程可能是先 new int, 然后调用g()。如果恰好g()发送异常，而shared_ptr 尚未创建，那么int内存就泄露了。
正确的写法是先创建智能指针，然后调用函数：
//函数参数是shared_ptr时，正确写法
shared_ptr<int> p1(new int());
f(p, g());
4、通过shared_from_this() 返回this指针。不要将this指针作为shared_ptr返回出来，因为this本质就是一个裸指针。因此，直接传this指针可能导致重复析构。
//将this作为shared_ptr返回，从而导致重复析构的错误实例
struct A {
shared_ptr<A> GetSelf() {
return shared_ptr<A>(this); // 不要这么做，可能导致重复析构
}
~A() {
std::cout<<"~A()"<<std::endl;
}
};
shared_ptr<A> p1(new A);
shared_ptr<A> p2=p1->GetSelf(); // A的对象将被析构两次，从而导致程序崩溃
本例中，用同一个指针(this) 构造了2个智能指针p1, p2 （两者无任何关联）， 离开作用域后，this会被构造的2个智能指针各自析构1次，从而导致重复析构的错误。
正确返回this的shared_ptr做法： 让目标类通过派生std::enable_shared_from_this类， 然后使用base class的成员函数shared_from_this来返回this的shared_ptr。
struct A: public enable_shared_from_this<A> {
shared_ptr<A> GetSelf() {
return shared_from_this ();
}
~A() {
std::cout<< "~A()" <<std::endl;
}
};
shared_ptr<A> p1(new A);
shared_ptr<A> p2=p1->GetSelf(); // ok
std::cout<< p2.use_count() <<std::endl; // 打印2，注意这里会引起指向A的raw pointer 对应的 shared_ptr的引用技术+1
5、避免循环引用。 循环引用会导致内存泄漏。
典型的循环引用case:
struct A;
struct B;
struct A {
std::shared_ptr<B> bptr;
~A() { std::cout<< "A is delete! " <<std::endl; }
}；
struct B {
std::shared_ptr<A> aptr;
~B() {std::cout<< "B is delete! "<< std::endl; }
};
void test() {
shared_ptr<A> ap(new A);
shared_ptr<B> bp(new B);
ap->bptr =bp;
bp->aptr =ap;
// A 和 B对象应该都被删除，然而实际情况都不会被删除： 没有析构调用析构函数
}
解决循环引用的有效方法是使用 weak_ptr。上例中，可以将A和B中任意一个成员变量，有shared_ptr修改为weak_ptr。
2.unique_ptr
unique_ptr基本用法
独占型智能指针，不允许与其他智能指针共享内部指针，不允许将一个unique_ptr赋值给另一个unique_ptr。
错误用法：
// 将一个unique_ptr赋值给另一个unique_ptr是错误的
unique_ptr<int> p1(new int);
unique_ptr<int> p2=p1; // 错误， unique_ptr不允许复制
正确用法： 可以移动(std::move) 。移动后，原来的unique_ptr不再拥有原来指针的所有权了，所有权移动给了新unique_ptr。
unique_ptr<int> p1(new int);
unique_ptr<int> p2=p1; // 错误，unique_ptr不允许赋值
unique_ptr<int> p3=std::move(p1); //ok
自定义make_unique创建unique_ptr
shared_ptr有辅助方法make_shared可以创建智能指针，但C++11中没有类似的make_unique（C++14才提供）。自定义make_unique方法（需要在C++11环境下运行）：
// 支持普通指针
template<class T, class... Args> inline
typename enable_if<!is_array<T>::value, unique_ptr<T>>::type
make_unique(Args&&... args) {
return unique_ptr<T>(new T(std::forward<Args>(args)...));
}
// 支持动态数组
template<class T> inline
typename enable_if<is_array<T>::value && extent<T>::value==0, unique_ptr<T>>::type
make_unique(size_t size) {
typedef typename remove_extent<T>::type U;
return unique_ptr<T>(new U[size]());
}
// 过滤掉定长数组的情况
template<class T, class... Args>
typename enable_if<extent<T>::value != 0, void>::type make_unique(Args&&...) = delete;
// 使用自定义make_unique创建unique_ptr
unique_ptr<int> p = make_unique<int>(10);
cout << *p << endl;
unique_ptr与shared_ptr的区别
如果希望同一时刻，只有一个智能指针管理资源，就用unique_ptr；如果希望多个智能指针管理同一个资源，就用shared_ptr。除了独占性外，unique_ptr与shared_ptr的区别：
1）unique_ptr可以指向一个数组，shared_ptr不能
unique_ptr<int []> ptr(new int[10]); // OK：智能指针ptr指向元素个数为10的int数组
ptr[9] = 9; // 设置最后一个元素为9
shared_ptr<int []> ptr(new int[10]); // 错误：C++11中，shared_ptr不能通过让模板参数为数组，从而让智能指针直接指向数组，因为默认删除器是delete，而数组需要delete[]（C++17中已经可用支持）
2）指定删除器时，不能像shared_ptr那样直接传入lambda表达式
shared_ptr<int> p(new int(1), [](int* p) { delete p; }); // OK
unique_ptr<int> p2(new int(1), [](int* p) { delete p; }); // 错误：为unique_ptr指定删除器时，需要确定删除器的类型
因为为unique_ptr指定删除器时，不能像shared_ptr那样，需要确定删除器的类型。像这样：
unique_ptr<int, void(*)(int *)> p2(new int(1), [](int* p) { delete p; }); // OK
如果lambda表达式捕获了变量，这种写法就是错误的：
unique_ptr<int, void(*)(int *)> p2(new int(1), [&](int* p) { delete p; }); // 错误：lambda无法转换为函数指针
因为lambda没有捕获变量时，可以直接转换为函数指针，而不会变量后，无法转换。
如果希望unique_ptr删除器支持已不会变量的lambda，可以将模板实参由函数类型修改为std::function类型（可调用对象）：
unique_ptr<int, function<void(int *)>> p2(new int(1), [&](int* p) { delete p; });
自定义unique_ptr删除器
#include <memory>
#include <iostream>
#include <functional>
using namespace std;
struct MyDeleter{
void operator()(int* p) {
cout << "delete" << endl;
delete p;
}
};
unique_ptr<int, MyDeleter> p(new int(1));
cout << *p << endl;
3.weak_ptr
弱引用智能指针weak_ptr用来监视shared_ptr，不会引起引用计数变化，也不管理shared_ptr内部指针，主要为了监视shared_ptr生命周期。weak_ptr没有重载操作符*和->，因为不共享指针，不能操作资源。
weak_ptr主要作用：
1）监视shared_ptr管理的资源是否存在；
2）用来返回this指针；
3）解决循环引用问题；
weak_ptr基本用法
1）通过use_count() 获得当前观测资源的引用计数。
shared_ptr<int> sp(new int(10));
weak_ptr<int> wp(sp);
cout << wp.use_count() << endl; // 打印1
2）通过expired() 判断所观测的资源释放已经被释放。
{
shared_ptr<int> sp(new int(10)); // sp所指向内容非空
weak_ptr<int> wp(sp);
if (wp.expired()) {
cout << "weak_ptr 无效，所监视的智能指针已经被释放" << endl;
}
else
cout << "weak_ptr 有效" << endl; // 输出 "weak_ptr 有效"
}
{
shared_ptr<int> sp; // sp所指向的内容为空
weak_ptr<int> wp(sp);
if (wp.expired()) {
cout << "weak_ptr 无效，所监视的智能指针已经被释放" << endl; // 输出 "weak_ptr 无效..."
}
else
cout << "weak_ptr 有效" << endl;
}
3）通过lock() 获取所监视的shared_ptr。
weak_ptr<int> wp;
void f() {
shared_ptr<int> sp(new int(10));
wp = sp;
if (wp.expired()) {
cout << "weak_ptr 无效，所监视的智能指针已经被释放" << endl;
}
else {
cout << "weak_ptr 有效" << endl; // 打印 "weak_ptr 有效"
auto spt = wp.lock();
cout << *spt << endl; // 打印10
}
}
weak_ptr返回this指针
上文提到不能直接将this指针返回为shared_ptr，需要通过继承enable_shared_from_this类，然后通过继承的shared_from_this()访问来返回智能指针。这是因为enable_shared_from_this类中有个weak_ptr，用于监测this智能指针，调用shared_from_this()方法时，会调用内部weak_ptr的lock()方法，将监测的shared_ptr返回。
之前提到的那个例子：
struct A : public std::enable_shared_from_this<A> {
std::shared_ptr<A> GetSelf() {
return shared_from_this();
}
~A() {
cout << "A is deleted" << endl;
}
};
shared_ptr<A> spy(new A);
shared_ptr<A> p = spy->GetSelf(); // OK. 如果A不用继承自enable_shared_from_this类的方法，直接传this指针给shared_ptr，会导致重复析构的问题
// 只会输出一次 "A is deleted"
weak_ptr解决循环引用问题
前面提到shared_ptr存在的循环引用的经典问题：A类持有指向B对象的shared_ptr，B类持有指向A对象的shared_ptr，导致2个shared_ptr引用计数无法归0，从而导致shared_ptr所指向对象无法正常释放。
struct A;
struct B;
struct A {
shared_ptr<B> bptr;
~A() { cout << "A is deleted" << endl; }
};
struct B {
shared_ptr<A> bptr;
~B() { cout << "B is deleted" << endl; }
};
void test() {
shared_ptr<A> pa(new A);
shared_ptr<B> pb(new B);
pa->bptr = pb;
pb->aptr = pa;
} // 离开函数作用域后，A、B对象应该销毁，但事实没有被销毁，从而导致内存泄漏
用weak_ptr解决循环引用问题，具体方法是将A或B类中，shared_ptr类型修改为weak_ptr。
struct A;
struct B;
struct A {
shared_ptr<B> bptr;
~A() { cout << "A is deleted" << endl; }
};
struct B {
weak_ptr<A> aptr; // 将B中指向A对象的智能指针，由shared_ptr修改为weak_ptr
~B() { cout << "B is deleted" << endl; }
};
void test() {
shared_ptr<A> pa(new A);
shared_ptr<B> pb(new B);
pa->bptr = pb;
pb->aptr = pa;
} // OK
通过智能指针管理第三方库分配的内存
第三方库提供的接口，通常是用的原始指针，而非智能指针。那么，我们在用完第三方库之后，如何通过智能指针管理第三方库分配的内存呢？
我们先看第三方库一般的用法：
// GetHandler()获取第三方库句柄
// Create, Release是第三方库提供的资源创建、释放接口
void* p = GetHandler()->Create();
// do something...
GetHandler()->Release();
实际上，上面这段代码是不安全的，原因在于：1）使用第三方库分配时，可能忘记调用Release接口；2）发生了异常，或者提前返回，实际并没有调用Release接口。从而导致资源无法正常释放。
使用智能指针管理第三方库，不要显式调用释放接口，即使发生异常或者忘记调用，也能正常释放资源。
如上面一般用法，可以改写成用智能指针的方式：
// OK
void* p = GetHandler()->Create();
shared_ptr<void> sp(p, [this](void* p) { GetHandle()->Release(p); };
上面代码可以保证任何时候，都能正确释放第三方库分配的内存。虽然能解决问题，但还很繁琐，因为每个第三方库分配内存的地方，就要调用这段代码。可将这段代码提炼出来作为一个公共函数，以简化调用：
// 存在安全隐患
// 将创建智能指针，用于管理第三方库的代码段封装到一个函数
shared_ptr<void> Guard(void* p) {
return shared_ptr<void> sp(p, [this](void* p) { GetHandler()->Release(p); });
}
void* p = GetHandler()->Create();
auto sp = Guard(p);
// do something with sp...
上面这段代码存在安全隐患：客户可能并不会利用Guard返回的临时shared_ptr，构造一个新的shared_ptr，这样p所创建的资源会立即释放。
// 安全隐患演示
void* p = GetHandler()->Create();
Guard(p); // 该句结束后，p就会被释放
// do something with p...
这种调用方式中，Guard§是一个右值，语句结束后创建的资源会立即释放，从而导致p提前释放，p成为野指针，而后面继续访问p可能导致程序异常。虽然用auto sp = Guard§;赋值不存在问题，但是客户可能会忘记，也就是说这种写法不够安全。
如何解决由于忘记赋值导致指针提前释放的问题？
答：可以用一个宏来解决这个问题，通过宏来强制创建一个临时智能指针。代码如：
// OK
#define GUARD(p) std::shared_ptr<void> p##p(p, [](void* p) { GetHandler()->Release(p); })
void* p = GetHandler()->Create();
GUARD(p); // 安全：会在当前作用域下，创建名为pp的shared_ptr<void>
当然，如果只希望用独占性的管理第三方库的资源，可以用unique_ptr。
/ OK
#define GUARD(p) std::unique_ptr<void, void(*)(int*)> p##p(p, [](void* p) { GetHandler()->Release(p); })
总结
1）使用宏定义方式的优势：即使忘记对智能指针赋值，也能正常运行，安全又方便。
2）使用GUARD这种智能指针管理第三方库的方式，其本质是智能指针，能在各种场景下正确释放内存。
