**shared\_ptr**是**C++11**提供的一种智能指针类，它足够智能，可以在任何地方都不使用时自动删除相关指针，从而帮助彻底消除内存泄漏和悬空指针的问题。
它遵循共享所有权的概念，即不同的 shared\_ptr 对象可以与相同的指针相关联，并在内部使用引用计数机制来实现这一点。
*****
**每个 shared\_ptr 对象在内部指向两个内存位置：**
1、指向对象的指针。
2、用于控制引用计数数据的指针。
*****
**共享所有权如何在参考计数的帮助下工作：**
1、当新的 shared\_ptr 对象与指针关联时，则在其构造函数中，将与此指针关联的引用计数增加1。
2、当任何 shared\_ptr 对象超出作用域时，则在其析构函数中，它将关联指针的引用计数减1。如果引用计数变为0，则表示没有其他 shared\_ptr 对象与此内存关联，在这种情况下，它使用`delete`函数删除该内存。
### 创建 shared\_ptr 对象
#### 使用原始指针创建 shared\_ptr 对象
~~~cpp
std::shared_ptr<int> p1(new int());
~~~
上面这行代码在堆上创建了两块内存：1：存储`int`。2：用于引用计数的内存，管理附加此内存的 shared\_ptr 对象的计数，最初计数将为1。
**检查 shared\_ptr 对象的引用计数**
~~~cpp
p1.use_count();
~~~
#### 创建空的 shared\_ptr 对象
因为带有参数的 shared\_ptr 构造函数是 explicit 类型的，所以不能像这样`std::shared_ptr<int> p1 = new int();`隐式调用它构造函数。创建新的shared\_ptr对象的最佳方法是使用**std :: make\_shared**：
~~~cpp
std::shared_ptr<int> p1 = std::make_shared<int>();
~~~
**std::make\_shared**一次性为`int`对象和用于引用计数的数据都分配了内存，而`new`操作符只是为`int`分配了内存。
### 分离关联的原始指针
要使 shared\_ptr 对象取消与相关指针的关联，可以使用`reset()`函数：
**不带参数的reset()：**
~~~cpp
p1.reset();
~~~
它将引用计数减少1，如果引用计数变为0，则删除指针。
**带参数的reset()：**
~~~cpp
p1.reset(new int(34));
~~~
在这种情况下，它将在内部指向新指针，因此其引用计数将再次变为1。
**使用nullptr重置：**
~~~cpp
p1 = nullptr;
~~~
#### shared\_ptr是一个伪指针
shared\_ptr充当普通指针，我们可以将`*`和`->`与 shared\_ptr 对象一起使用，也可以像其他 shared\_ptr 对象一样进行比较;
#### 完整示例
~~~cpp
#include <iostream>
#include <memory> // 需要包含这个头文件
int main()
{
// 使用 make_shared 创建空对象
std::shared_ptr<int> p1 = std::make_shared<int>();
*p1 = 78;
std::cout << "p1 = " << *p1 << std::endl; // 输出78
// 打印引用个数：1
std::cout << "p1 Reference count = " << p1.use_count() << std::endl;
// 第2个 shared_ptr 对象指向同一个指针
std::shared_ptr<int> p2(p1);
// 下面两个输出都是：2
std::cout << "p2 Reference count = " << p2.use_count() << std::endl;
std::cout << "p1 Reference count = " << p1.use_count() << std::endl;
// 比较智能指针，p1 等于 p2
if (p1 == p2) {
std::cout << "p1 and p2 are pointing to same pointer\n";
}
std::cout<<"Reset p1 "<<std::endl;
// 无参数调用reset，无关联指针，引用个数为0
p1.reset();
std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
// 带参数调用reset，引用个数为1
p1.reset(new int(11));
std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
// 把对象重置为NULL，引用计数为0
p1 = nullptr;
std::cout << "p1 Reference Count = " << p1.use_count() << std::endl;
if (!p1) {
std::cout << "p1 is NULL" << std::endl; // 输出
}
return 0;
}
~~~
### 自定义删除器 Deleter
下面将讨论如何将自定义删除器与 std :: shared\_ptr 一起使用。
当 shared\_ptr 对象超出范围时，将调用其析构函数。在其析构函数中，它将引用计数减1，如果引用计数的新值为0，则删除关联的原始指针。
析构函数中删除内部原始指针，默认调用的是`delete()`函数。
~~~cpp
delete Pointer;
~~~
有些时候在析构函数中，delete函数并不能满足我们的需求，可能还想加其他的处理。
#### 当 shared\_ptr 对象指向数组
~~~cpp
std::shared_ptr<int> p3(new int[12]);
~~~
像这样申请的数组，应该调用`delete []`释放内存，而shared\_ptr析构函数中默认`delete`并不能满足需求。
#### 给shared\_ptr添加自定义删除器
在上面在这种情况下，我们可以将回调函数传递给 shared\_ptr 的构造函数，该构造函数将从其析构函数中调用以进行删除，即
~~~cpp
// 自定义删除器
void deleter(Sample * x)
{
std::cout << "DELETER FUNCTION CALLED\n";
delete[] x;
}
// 构造函数传递自定义删除器指针
std::shared_ptr<Sample> p3(new Sample[12], deleter);
~~~
下面看一个完整的示例：
~~~cpp
#include <iostream>
#include <memory>
struct Sample
{
Sample() {
std::cout << "Sample\n";
}
~Sample() {
std::cout << "~Sample\n";
}
};
void deleter(Sample * x)
{
std::cout << "Custom Deleter\n";
delete[] x;
}
int main()
{
std::shared_ptr<Sample> p3(new Sample[3], deleter);
return 0;
}
~~~
输出：
~~~txt
Sample
Sample
Sample
Custom Deleter
~Sample
~Sample
~Sample
~~~
#### 使用Lambda 表达式 / 函数对象作为删除器
~~~cpp
class Deleter
{
public:
void operator() (Sample * x) {
std::cout<<"DELETER FUNCTION CALLED\n";
delete[] x;
}
};
// 函数对象作为删除器
std::shared_ptr<Sample> p3(new Sample[3], Deleter());
// Lambda表达式作为删除器
std::shared_ptr<Sample> p4(new Sample[3], [](Sample * x){
std::cout<<"DELETER FUNCTION CALLED\n";
delete[] x;
});
~~~
### shared\_ptr 相对于普通指针的优缺点
#### 缺少 ++, – – 和 \[\] 运算符
与普通指针相比，shared\_ptr仅提供`->`、`*`和`==`运算符，没有`+`、`-`、`++`、`--`、`[]`等运算符。
示例：
~~~cpp
#include<iostream>
#include<memory>
struct Sample {
void dummyFunction() {
std::cout << "dummyFunction" << std::endl;
}
};
int main()
{
std::shared_ptr<Sample> ptr = std::make_shared<Sample>();
(*ptr).dummyFunction(); // 正常
ptr->dummyFunction(); // 正常
// ptr[0]->dummyFunction(); // 错误方式
// ptr++; // 错误方式
//ptr--; // 错误方式
std::shared_ptr<Sample> ptr2(ptr);
if (ptr == ptr2) // 正常
std::cout << "ptr and ptr2 are equal" << std::endl;
return 0;
}
~~~
#### NULL检测
当我们创建 shared\_ptr 对象而不分配任何值时，它就是空的；普通指针不分配空间的时候相当于一个野指针，指向垃圾空间，且无法判断指向的是否是有用数据。
**shared\_ptr 检测空值方法**
~~~cpp
std::shared_ptr<Sample> ptr3;
if(!ptr3)
std::cout<<"Yes, ptr3 is empty" << std::endl;
if(ptr3 == NULL)
std::cout<<"ptr3 is empty" << std::endl;
if(ptr3 == nullptr)
std::cout<<"ptr3 is empty" << std::endl;
~~~
### 创建 shared\_ptr 时注意事项
#### 不要使用同一个原始指针构造 shared\_ptr
创建多个 shared\_ptr 的正常方法是使用一个已存在的shared\_ptr 进行创建，而不是使用同一个原始指针进行创建。
示例：
~~~cpp
int *num = new int(23);
std::shared_ptr<int> p1(num);
std::shared_ptr<int> p2(p1); // 正确使用方法
std::shared_ptr<int> p3(num); // 不推荐
std::cout << "p1 Reference = " << p1.use_count() << std::endl; // 输出 2
std::cout << "p2 Reference = " << p2.use_count() << std::endl; // 输出 2
std::cout << "p3 Reference = " << p3.use_count() << std::endl; // 输出 1
~~~
假如使用原始指针`num`创建了p1，又同样方法创建了p3，当p1超出作用域时会调用`delete`释放`num`内存，此时num成了悬空指针，当p3超出作用域再次`delete`的时候就可能会出错。
#### 不要用栈中的指针构造 shared\_ptr 对象
shared\_ptr 默认的构造函数中使用的是`delete`来删除关联的指针，所以构造的时候也必须使用`new`出来的堆空间的指针。
示例：
~~~cpp
#include<iostream>
#include<memory>
int main()
{
int x = 12;
std::shared_ptr<int> ptr(&x);
return 0;
}
~~~
当 shared\_ptr 对象超出作用域调用析构函数`delete`指针`&x`时会出错。
#### 建议使用 make\_shared
为了避免以上两种情形，建议使用`make_shared()<>`创建 shared\_ptr 对象，而不是使用默认构造函数创建。
~~~cpp
std::shared_ptr<int> ptr_1 = make_shared<int>();
std::shared_ptr<int> ptr_2 (ptr_1);
~~~
另外不建议使用`get()`函数获取 shared\_ptr 关联的原始指针，因为如果在 shared\_ptr 析构之前手动调用了`delete`函数，同样会导致类似的错误。
- C++基础
- 什么是 POD 数据类型？
- 面向对象三大特性五大原则
- 低耦合高内聚
- C++类型转换
- c++仿函数
- C++仿函数了解一下？
- C++对象内存模型
- C++11新特性
- 智能指针
- 动手实现C++的智能指针
- C++ 智能指针 shared_ptr 详解与示例
- 现代 C++：一文读懂智能指针
- Lamda
- c++11多线程
- std::thread
- std::async
- std::promise
- std::future
- C++11 的内存模型
- 初始化列表
- std::bind
- std::tuple
- auto自动类型推导
- 可变参数模板
- 右值引用与移动语义
- 完美转发
- 基于范围的for循环
- C++11之POD类型
- std::enable_if
- C++14/17
- C++20
- 协成
- 模块
- Ranges
- Boost
- boost::circular_buffer
- 使用Boost.Asio编写通信程序
- Boost.Asio C++ 网络编程
- 模板
- 模板特化/偏特化
- C++模板、类模板、函数模板详解都在这里了
- 泛化之美--C++11可变模版参数的妙用
- 模板元编程
- 这是我见过最好的模板元编程文章！