目录
1.为什么要使用智能指针？
智能指针就是帮我们C++程序员管理动态分配的内存的，它会帮助我们自动释放new出来的内存，从而避免内存泄漏！
那么咱们看下面的一个例子：
#include <iostream>
#include <string>
#include <memory>
using namespace std;
// 动态分配内存，没有释放就return
void memoryLeak1() {
string *str = new string("动态分配内存！");
return;
}
// 动态分配内存，虽然有些释放内存的代码，但是被半路截胡return了
int memoryLeak2() {
string *str = new string("内存泄露！");
// ...此处省略一万行代码
// 发生某些异常，需要结束函数
if (1) {
return -1;
}
/
// 另外，使用try、catch结束函数，也会造成内存泄漏！
/
delete str; // 虽然写了释放内存的代码，但是遭到函数中段返回，使得指针没有得到释放
return 1;
}
int main(void) {
memoryLeak1();
memoryLeak2();
return 0;
}
memoryLeak1函数中，new了一个字符串指针，但是没有delete就已经return结束函数了，导致内存没有被释放，内存泄露！
memoryLeak2函数中，new了一个字符串指针，虽然在函数末尾有些释放内存的代码delete str，但是在delete之前就已经return了，所以内存也没有被释放，内存泄露！
使用指针，我们没有释放，就会造成内存泄露。但是我们使用普通对象却不会！
而智能指针恰好就是一个指针对象，可以帮助我们自动释放内存的指针对象。
2.RAII和智能指针的设计思路
1.RAII是ResourceAcquisition Is Initialization的缩写，他是⼀种管理资源的类的设计思想，本质是 ⼀种利用对象生命周期来管理获取到的动态资源，避免资源泄漏，这里的资源可以是内存、文件指 针、网络连接、互斥锁等等。RAII在获取资源时把资源委托给⼀个对象，接着控制对资源的访问， 资源在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常 释放，避免资源泄漏问题。
2. 智能指针类除了满足RAII的设计思路，还要方便资源的访问，所以智能指针类还会想迭代器类⼀ 样，重载 operator*/operator->/operator[] 等运算符，方便访问资源。（因为你一个智能指针，下面有好多个接口，所以你的智能指针得准备完全这个功能才可以）。
那么，在将解智能指针之前，还得先来讲一下删除器。
3.删除器
struct Date
{
int _year;
int _month;
int _day;
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
~Date()
{
cout << "~Date()" << endl;
}
};
template<class T>
void DeleteArrayFunc(T* ptr)
{
delete[] ptr;
}
template<class T>
class DeleteArray
{
public:
void operator()(T* ptr)
{
delete[] ptr;
}
};
class Fclose
{
public:
void operator()(FILE* ptr)
{
cout << "fclose:" << ptr << endl;
fclose(ptr);
}
};
int main()
{
// 这样实现程序会崩溃
// unique_ptr<Date> up1(new Date[10]);
// shared_ptr<Date> sp1(new Date[10]);
// 解决⽅案1
// 因为new[]经常使⽤，所以unique_ptr和shared_ptr
// 实现了⼀个特化版本，这个特化版本析构时⽤的delete[]
//对于`unique_ptr`，其特化版本大致如下（简化）：
//template <typename T>
//class unique_ptr<T[]> {
//public:
// // ... 其他成员函数
// ~unique_ptr() {
// delete[] ptr;
// }
//};
//注意：以上只是概念上的简化，实际实现更为复杂。
unique_ptr<Date[]> up1(new Date[5]);
shared_ptr<Date[]> sp1(new Date[5]);
// 解决⽅案2
// 仿函数对象做删除器
//unique_ptr<Date, DeleteArray<Date>> up2(new Date[5], DeleteArray<Date>());
// unique_ptr和shared_ptr⽀持删除器的⽅式有所不同
// unique_ptr是在类模板参数⽀持的，shared_ptr是构造函数参数⽀持的
// 这⾥没有使⽤相同的⽅式还是挺坑的
// 使⽤仿函数unique_ptr可以不在构造函数传递，因为仿函数类型构造的对象直接就可以调⽤
// 但是下⾯的函数指针和lambda的类型不可以
unique_ptr<Date, DeleteArray<Date>> up2(new Date[5]);
shared_ptr<Date> sp2(new Date[5], DeleteArray<Date>());
// 函数指针做删除器
unique_ptr<Date, void(*)(Date*)> up3(new Date[5], DeleteArrayFunc<Date>);
shared_ptr<Date> sp3(new Date[5], DeleteArrayFunc<Date>);
// lambda表达式做删除器
auto delArrOBJ = [](Date* ptr) {delete[] ptr; };
unique_ptr<Date, decltype(delArrOBJ)> up4(new Date[5], delArrOBJ);
shared_ptr<Date> sp4(new Date[5], delArrOBJ);
// 实现其他资源管理的删除器
shared_ptr<FILE> sp5(fopen("Test.cpp", "r"), Fclose());
shared_ptr<FILE> sp6(fopen("Test.cpp", "r"), [](FILE* ptr) {
cout << "fclose:" << ptr << endl;
fclose(ptr);
});
return 0;
}咱们接下来看几个问题：
1.为什么unique_ptr<Date> up1(new Date[10]);shared_ptr<Date> sp1(new Date[10]);程序会崩溃，unique_ptr<Date[]> up1(new Date[5]);shared_ptr<Date[]> sp1(new Date[5]);而这个程序就不会崩溃呢？
原因在于删除方式不匹配。
1. 当我们使用`new[]`分配数组时，必须使用`delete[]`来释放内存。如果使用`delete`（而不是`delete[]`）来释放数组，行为是未定义的（Undefined Behavior）。对于非平凡析构的类型（即类有析构函数），这通常会导致程序崩溃，因为`delete`只会调用第一个元素的析构函数，而不会调用整个数组的析构函数，并且释放内存的方式也不正确。
2. 在提供的代码中，`unique_ptr`和`shared_ptr`的默认删除器是`delete`。因此：
- `unique_ptr<Date> up1(new Date[10]);`：`unique_ptr`的默认删除器是`delete`，但这里分配的是一个数组，应该用`delete[]`。所以当`up1`析构时，它会调用`delete`来释放内存，而不是`delete[]`，导致未定义行为（崩溃）。
- 同样，`shared_ptr<Date> sp1(new Date[10]);`：`shared_ptr`的默认删除器也是`delete`，同样会导致错误。
3. 而`unique_ptr<Date[]> up1(new Date[5]);`和`shared_ptr<Date[]> sp1(new Date[5]);`使用了特化版本：
- `unique_ptr`有一个针对数组的特化版本`unique_ptr<T[]>`，其默认删除器是`delete[]`，因此会正确释放数组。
- C++17开始，`shared_ptr`也支持数组特化（`shared_ptr<T[]>`），并且使用`delete[]`作为删除器。
因此，使用特化版本（`unique_ptr<T[]>`和`shared_ptr<T[]>`）不会崩溃，因为它们使用了正确的删除方式。
2.unique_ptr 是在类模板参数支持的， shared_ptr 是构造函数参数支持的 。
3.定制删除方式，最好用shared_ptr，其次就是最好用lambda做删除器。
4.注意：lambda表达式每个都是唯一的类型，所以用`decltype(delArrOBJ)`来获取类型。
其余的方式都在上面的代码中，基本上用仿函数、函数指针、lambda表达式等自定义删除器。
C++标准库中的智能指针都在 <memory>这个头文件下面，我们包含<memory>就可以是使用了， 智能指针有好几种，除了weak_ptr他们都符合RAII和像指针⼀样访问的行为，原理上而言主要是解 决智能指针拷贝时的思路不同。
那么，C++的智能指针的发展史挺曲折的，为什么这么说呢？第一代的auto_ptr智能指针，可被骂惨了。之后的shared_ptr,unique_ptr才好起来，至于weak_ptr只是为了解决shared_ptr这个智能指针中出现的某种问题而产生的。那么下面就听作者来讲解
4.auto_ptr
4.1 auto_ptr的使用
auto_ptr是C++98时设计出来的智能指针，他的特点是拷贝时把被拷贝对象的资源的管理权转移给 拷贝对象，这是⼀个非常糟糕的设计，因为他会导致被拷贝对象悬空，那这个一旦指针悬空了，那可就很危险了，所以知道为什么当时这个智能指针出来之后，很多公司不愿意用它。
其实这个地方，咱们还是想用浅拷贝，不想用深拷贝，为什么呢？因为智能指针不是拥有资源，是代管资源。那么既然是代管资源，这个智能指针拷贝的时候，难道不应该两个都指向同一个对象吗？所以，咱们希望是浅拷贝。
例如，上面这个图，auto_ptr就是将，假如，将这个对象的资源管理权交给sp3,好，然后呢，好家伙，sp1这个指针，悬空了，你说可怎么办吧。
struct Date
{
int _year;
int _month;
int _day;
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
~Date()
{
cout << "~Date()" << endl;
}
};
int main()
{
auto_ptr<Date> ap1(new Date(2025, 6, 6));
// 拷贝时管理权转移，就导致ap1悬空
auto_ptr<Date> ap2(ap1);
// 悬空访问
ap1->_year++;//此时你再去运行，就会显示报错
return 0;
}看如上代码即可看出，你对一个已经悬空的指针进行操作，是会报错的。
4.2 auto_ptr的原理
这个auto_ptr的原理还是挺简单的：
template<class T>
class auto_ptr
{
public:
auto_ptr(T* ptr)
:_ptr(ptr)
{}
auto_ptr(auto_ptr<T>& sp)
:_ptr(sp._ptr)
{
// 管理权转移
sp._ptr = nullptr;
}
auto_ptr<T>& operator=(auto_ptr<T>& ap)
{
// 检测是否为⾃⼰给⾃⼰赋值
if (this != &ap)
{
// 释放当前对象中资源
if (_ptr)
delete _ptr;
// 转移ap中资源到当前对象中
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
~auto_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针⼀样使⽤
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
private:
T* _ptr;
};5.unique_ptr
5.1 unique_ptr的使用：
unique_ptr是C++11设计出来的智能指针，他的名字翻译出来是唯⼀指针，他的特点的不支持拷 贝，只支持移动。如果不需要拷贝的场景就非常建议使用他。
struct Date
{
int _year;
int _month;
int _day;
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
~Date()
{
cout << "~Date()" << endl;
}
};
int main()
{
unique_ptr<Date> up1(new Date);
// 不⽀持拷⻉
//unique_ptr<Date> up2(up1);
// ⽀持移动，但是移动后up1也悬空，所以使⽤移动要谨慎
unique_ptr<Date> up3(move(up1));
return 0;
}5.2 unique_ptr的原理：
template<class T>
class unique_ptr
{
public:
explicit unique_ptr(T* ptr)
:_ptr(ptr)
{}
~unique_ptr()
{
if (_ptr)
{
cout << "delete:" << _ptr << endl;
delete _ptr;
}
}
// 像指针⼀样使⽤
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
//由于不支持拷贝构造以及赋值，所以就把这两个给禁掉了
unique_ptr(const unique_ptr<T>&sp) = delete;
unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
unique_ptr(unique_ptr<T> && sp)
:_ptr(sp._ptr)
{
sp._ptr = nullptr;
}
unique_ptr<T>& operator=(unique_ptr<T> && sp)
{
delete _ptr;
_ptr = sp._ptr;
sp._ptr = nullptr;
}
private:
T* _ptr;
};这个unique_ptr就是不让用拷贝，只可以移动，大家记住这个就可以了。
6.shared_ptr
6.1 shared_ptr的使用：
不知道大家还记不记得，博主之前有一篇文章讲过写时拷贝，那么这个写时拷贝，就是运用了一个叫做引用计数的东西。
这个地方，你不是害怕析构两次嘛。OK，这里引入了“引用计数”。就是，你有几个shared_ptr指针指向这个对象，那么引用计数就是几。之后，你要是想释放掉这个对象里的资源，你得等到引用计数减为0的时候才可以释放。
`shared_ptr`是一种智能指针，它通过引用计数来管理对象的生命周期。多个`shared_ptr`可以指向同一个对象，当最后一个指向该对象的`shared_ptr`被销毁时，对象才会被析构。
### 引用计数的原理
1. * *引用计数的存储 * *：引用计数通常是一个动态分配的整数（或者更精确地说，是一个控制块的一部分，该控制块还包含其他信息，如删除器等）。每个由`shared_ptr`管理的对象都有一个关联的引用计数。
2. * *计数的增减 * *：
- 当一个新的`shared_ptr`被创建并指向同一个对象时（例如通过拷贝构造函数、拷贝赋值运算符等），引用计数会增加。
- 当一个`shared_ptr`被销毁（例如离开作用域）或者不再指向该对象（例如被重置）时，引用计数会减少。
3. * *计数为0 * *：当引用计数变为0时，表示没有任何`shared_ptr`指向该对象，此时对象会被删除（通过调用其析构函数，然后释放内存）。
### 为什么引用计数变为0时才析构？
- **目的 * *：确保对象在所有使用者都不再需要它时才被销毁，避免悬空指针和内存泄漏。
- **原理 * *：只要还有至少一个`shared_ptr`指向该对象，引用计数就大于0，对象就应该保持有效。只有当所有拥有该对象所有权的`shared_ptr`都释放了（即引用计数归零），才表示没有任何代码再需要访问该对象，此时安全地销毁对象。
### 注意- **循环引用 * *：如果两个对象使用`shared_ptr`相互引用，则引用计数永远不会变为0，导致内存泄漏。这时需要使用`weak_ptr`来打破循环。（这个咱们后面会讲到的）
### 总结
`shared_ptr`的引用计数机制提供了一种自动管理对象生命周期的便捷方式，确保对象在不再被需要时被销毁。这种机制的核心是：当引用计数减到0时，意味着没有任何智能指针指向该对象，因此可以安全释放。
为何引用计数为 0 才析构？
唯一性原则：引用计数为 0 表明没有任何 shared_ptr 再需要该对象。资源安全：若提前析构（如计数 > 0 时），会导致其他持有该对象的 shared_ptr 成为悬空指针。
内存泄漏预防：若永不析构（如循环引用），会导致内存泄漏。
案例：
{
shared_ptr<MyObj> p1(new MyObj); // 计数=1
{
shared_ptr<MyObj> p2 = p1; // 计数=2
} // p2 析构 → 计数=1
} // p1 析构 → 计数=0 → 调用 MyObj 析构函数
现在大家应该清楚shared_ptr是个怎么一回事了，那么接下来咱们来看一下代码：
struct Date
{
int _year;
int _month;
int _day;
Date(int year = 1, int month = 1, int day = 1)
:_year(year)
, _month(month)
, _day(day)
{}
~Date()
{
cout << "~Date()" << endl;
}
};
int main()
{
shared_ptr<Date> sp1(new Date);
// ⽀持拷⻉
shared_ptr<Date> sp2(sp1);
shared_ptr<Date> sp3(sp2);
cout << sp1.use_count() << endl;
sp1->_year++;
cout << sp1->_year << endl;
cout << sp2->_year << endl;
cout << sp3->_year << endl;
// ⽀持移动，但是移动后sp1也悬空，所以使⽤移动要谨慎
shared_ptr<Date> sp4(move(sp1));
return 0;
}1.cout << sp1.use_count() << endl 输出 3。（这个use_count()是shared_ptr提供的接口函数，作用是可以查出来这个sp1的引用计数是多少）。
2.sp1->_year++ 将对象的 _year 从默认值 1 增至 2。 由于 sp1、sp2、sp3 共享同一对象，cout 输出的 _year 均为 2。
3.shared_ptr<Date> sp4(move(sp1)) 将 sp1 的所有权转移至 sp4。 移动后，sp1 变为空指针（悬空），sp4 的引用计数为 3（继承自原 sp1）。
OK，那么这个shared_ptr的使用相信大家已经很清楚了，那么接下来来看原理代码：
6.2 make_shared
在此之前，先将一个东西：
shared_ptr<Date> sp1(new Date(2024, 9, 11));
shared_ptr<Date> sp2 = make_shared<Date>(2024, 9, 11);
第一行的代码等价于第二行的代码，等价于第三行的代码
auto sp3 = make_shared<Date>(2024, 9, 11);shared_ptr除了支持用指向资源的指针构造，还支持make_shared用初始化资源对象的值直接构造。
咱们来看一个 工厂函数，为什么将make_shared称为工厂函数呢？咱们知道工厂是干嘛的？是不是不管你的原材料是什么样的，最后出来的成品是不是都是一样的，（虽然样貌不同，但是用法一定是相同的）。
所以，`std::make_shared`提供了一种统一的方式来创建`std::shared_ptr`管理的对象。用户只需传递构造参数，函数内部负责分配内存和构造对象。用户不需要显式地使用`new`操作符，也不需要直接处理原始指针，从而避免了内存泄漏的风险。是不是很好呢？确实是的。
make_shared的本质呢，其实是一个可变函数参数模板。它通过构造T对象的参数包，底层呢，其实底层也是使用了new,但运用了完美转发，使参数保持原有的属性，最后再返回即可。
6.3 shared_ptr的使用原理：
这个的使用原来还是比较重要的。
template<class T>
class shared_ptr
{
public:
explicit shared_ptr(T* ptr = nullptr)
: _ptr(ptr)
, _pcount(new int(1))// 创建新的引用计数，初始化为1
{}
// 带自定义删除器的构造函数
template<class D>
shared_ptr(T* ptr, D del)
: _ptr(ptr)
, _pcount(new int(1))// 引用计数初始化为1
, _del(del)// 存储自定义删除器
{}
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)// 共享同一指针
, _pcount(sp._pcount)// 共享引用计数
, _del(sp._del)// 共享删除器
{
++(*_pcount);// 引用计数+1
}
void release()
{
if (--(*_pcount) == 0)// 引用计数-1
{
// 最后⼀个管理的对象，释放资源
_del(_ptr);// 使用删除器释放资源
delete _pcount;// 释放引用计数内存
_ptr = nullptr;// 置空指针
_pcount = nullptr;// 置空计数指针
}
}
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (_ptr != sp._ptr)// 避免自赋值
{
release();// 释放当前资源
//这个地方的拷贝赋值涉及到几个问题。1.拷贝构造是把一个已经存在的
//对象拷贝到不存在的对象上面，所以，这个不需要释放拷贝目标对象的资源。
//但是赋值，是等号两边的对象都存在资源，所以，你如果说不释放等号左边的对象的资源
//直接赋值的话，可能会导致左边资源找不到了。
//2.所以咱们得先释放左边的资源：
//那么释放资源，要注意，如果这个资源是多个对象共同管理的，就像这个一样
//这个sp1资源目前是sp1,sp2共同管理的，你如果说直接释放资源的话，然后再赋值，会导致sp2的资源找不到了
// 并且，这个资源是sp1，sp2共同管理的，凭什么资源的释放由你一个人决定？
// 所以，就有了计数，如果计数等于0，说明：目前没有对象在管理这个资源，那么此时直接释放了，没有任何问题
// 要是计数不等于0，说明，还是有对象在管理这个资源，那么此时，只需要我放手，不管理这个资源了，我去管理sp3的资源即可
// 这个原先的资源交给sp2去管理。所以，计数的作用就体现在这里
//(这里所说的对象，就是shared_ptr指针，对象管理的资源就是shared_ptr所指向的对象）
// 复制新资源
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);// 新资源的引用计数+1
_del = sp._del;
}
return *this;
}
~shared_ptr()
{
release();// 释放资源（引用计数-1，为0时删除对象）
}
T* get() const
{
return _ptr;// 获取原始指针
}
int use_count() const
{
return *_pcount;// 获取引用计数
}
T& operator*()
{
return *_ptr;// 解引用
}
T* operator->()
{
return _ptr;// 成员访问
}
private:
T* _ptr;
int* _pcount;
//atomic<int>* _pcount;
function<void(T*)> _del = [](T* ptr) {delete ptr; };//这个地方注意要加上
//缺省值，为什么呢？是因为你如果说，我传的是调用的是普通的delete的，
//那么这个参数列表是必须要走的，但你要是不给_del缺省值，这个地方是不是空
//那么这个地方是空的话，上面release的_del(_ptr)，空的调用_ptr，会抛异常，bad_function_call异常
};看清楚上面是如何设计的（这个版本涉及到自定义删除器）。注意，这个地方使用的是*_pcount用来计一下引用计数，而不是使用static int _pcount来引用计数。原因是因为：
比如上面的这俩，你使用静态的，对于sp1，sp2来说可能正好，但是对于sp3来说呢？静态变量不光sp1，sp2可以使用，sp3也可以使用。但是sp3跟1，2管理的不是同一个对象呀，所以，不可以使用静态变量。要使用堆上动态开辟的方式，构造智 能指针对象时来⼀份资源，就要new⼀个引用计数出来。多个shared_ptr指向资源时就++引用计 数，shared_ptr对象析构时就--引用计数，引用计数减到0时代表当前析构的shared_ptr是最后⼀ 个管理资源的对象，则析构资源。
另外的一些其他的挺重要的，我都放到代码中了，大家自行阅读。
还有一点：为什么上面的每一个构造函数前面都加上了explicit呢？这是因为，智能指针不允许进行隐式类型转换。就是不允许从原始指针，转换为智能指针。
void func(shared_ptr<Date> sp);//这个函数里面是智能指针
Date* raw_ptr = new Date;//原始指针
func(raw_ptr); // 危险！隐式转换为 shared_ptr
比如上面的这个例子。
7.shared_ptr的线程安全问题
1.shared_ptr的引用计数对象在堆上，如果多个shared_ptr对象在多个线程中，进行shared_ptr的拷 贝析构时会访问修改引用计数，就会存在线程安全问题，所以shared_ptr引用计数是需要加锁或者 原子操作保证线程安全的。
2. shared_ptr指向的对象也是有线程安全的问题的，但是这个对象的线程安全问题不归shared_ptr 管，它也管不了，应该有外层使用shared_ptr的人进行线程安全的控制。
3. 下⾯的程序会崩溃或者A资源没释放，shared_ptr引用计数从int*改成atomic*就可以保证 引用计数的线程安全问题，或者使用互斥锁加锁也可以。（这个可能得等到Linux章节里才会讲）。
struct AA
{
int _a1 = 0;
int _a2 = 0;
~AA()
{
cout << "~AA()" << endl;
}
};
int main()
{
shared_ptr<AA> p(new AA);
const size_t n = 100000;
mutex mtx;
auto func = [&]()
{
for (size_t i = 0; i < n; ++i)
{
// 这⾥智能指针拷⻉会++计数
shared_ptr<AA> copy(p);
{
unique_lock<mutex> lk(mtx);
copy->_a1++;
copy->_a2++;
}
}
};
thread t1(func);
thread t2(func);
t1.join();
t2.join();
cout << p->_a1 << endl;
cout << p->_a2 << endl;
cout << p.use_count() << endl;
return 0;
}
输出结果为：
200000 200000 1 ~AA()
OK，那么咱们来看一下经过这个版本，改后的shared_ptr的底层代码：
#include<functional>
#include<atomic>
template<class T>
class shared_ptr
{
public:
template<class D>
shared_ptr(T* ptr, D del)
:_ptr(ptr)
, _pcount(new atomic<int>(1))
, _del(del)
{}
shared_ptr(T* ptr = nullptr)
:_ptr(ptr)
, _pcount(new atomic<int>(1))
{}
// sp2(sp1)
shared_ptr(const shared_ptr<T>& sp)
:_ptr(sp._ptr)
, _pcount(sp._pcount)
{
++(*_pcount);
}
// sp1 = sp3
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
if (_ptr != sp._ptr)
{
release();//这个地方的拷贝赋值涉及到几个问题。1.拷贝构造是把一个已经存在的
//对象拷贝到不存在的对象上面，所以，这个不需要释放拷贝目标对象的资源。
//但是赋值，是等号两边的对象都存在资源，所以，你如果说不释放等号左边的对象的资源
//直接赋值的话，可能会导致左边资源找不到了。
//2.所以咱们得先释放左边的资源：
//那么释放资源，要注意，如果这个资源是多个对象共同管理的，就像这个一样
//这个sp1资源目前是sp1,sp2共同管理的，你如果说直接释放资源的话，然后再赋值，会导致sp2的资源找不到了
// 并且，这个资源是sp1，sp2共同管理的，凭什么资源的释放由你一个人决定？
// 所以，就有了计数，如果计数等于0，说明：目前没有对象在管理这个资源，那么此时直接释放了，没有任何问题
// 要是计数不等于0，说明，还是有对象在管理这个资源，那么此时，只需要我放手，不管理这个资源了，我去管理sp3的资源即可
// 这个原先的资源交给sp2去管理。所以，计数的作用就体现在这里
//(这里所说的对象，就是shared_ptr指针，对象管理的资源就是shared_ptr所指向的对象）
_ptr = sp._ptr;
_pcount = sp._pcount;
++(*_pcount);//引用计数加1，是因为又有一个对象来管理这个资源.
}
return *this;
}
void release()
{
if (--(*_pcount) == 0)
{
//delete _ptr;
_del(_ptr);
delete _pcount;
}
}
~shared_ptr()
{
release();
}
// ָһʹ
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* get()
{
return _ptr;
}
int use_count()
{
return *_pcount;
}
operator bool()
{
return _ptr != nullptr;
}
private:
T* _ptr;// 管理的原始指针
//int* _pcount;
atomic<int>* _pcount;// 引用计数指针
function<void(T*)> _del = [](T* ptr) {delete ptr; };//这个地方注意要加上
//缺省值，为什么呢？是因为你如果说，我传的是调用的是普通的delete的，
//那么这个参数列表是必须要走的，但你要是不给_del缺省值，这个地方是不是空
//那么这个地方是空的话，上面release的_del(_ptr)，空的调用_ptr，会抛异常，bad_function_call异常
};8.shared_ptr循环引用问题
先来看一段代码：
struct ListNode
{
int _data;
/*ListNode* _next;
ListNode* _prev;*/
/*std::shared_ptr<ListNode> _next;
std::shared_ptr<ListNode> _prev;*/
std::weak_ptr<ListNode> _next;
std::weak_ptr<ListNode> _prev;
~ListNode()
{
cout << "~ListNode()" << endl;
}
};
int main()
{
// 循环引用 -- 内存泄露
std::shared_ptr<ListNode> n1(new ListNode);
std::shared_ptr<ListNode> n2(new ListNode);
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
n1->_next = n2;
n2->_prev = n1;
cout << n1.use_count() << endl;
cout << n2.use_count() << endl;
return 0;
}代码中定义了一个链表节点结构体ListNode，它包含：
int _data;
shared_ptr<ListNode> _next;
shared_ptr<ListNode> _prev;
在main函数中，创建了两个共享指针n1和n2，分别指向两个ListNode对象。
初始时，n1和n2的引用计数都是1。
然后执行：
n1->_next = n2; // 这会让n2的引用计数增加1（因为_next是shared_ptr，赋值会拷贝，所以n2的引用计数变为2）
n2->_prev = n1; // 这会让n1的引用计数增加1（同理，n1的引用计数变为2）
当main函数结束时，n1和n2的生命周期结束，它们的析构函数被调用，会分别将引用计数减1。
此时，n1指向的节点的引用计数从2减为1（因为n2的_prev还指向它），所以不会释放n1节点。(因为shared_ptr只有在引用计数为0的时候，才会去释放这个对象，所以，这个问题的本质还是因为引用计数不为0，就是shared_ptr会增加引用计数）
同样，n2指向的节点的引用计数从2减为1（因为n1的_next还指向它），所以也不会释放n2节点。
这样就形成了循环引用，导致内存泄漏。
将_next和_prev改为weak_ptr。因为weak_ptr不会增加引用计数。
修改后的ListNode：
struct ListNode
{
int _data;
std::weak_ptr<ListNode> _next;
std::weak_ptr<ListNode> _prev;
~ListNode() { cout << "~ListNode()" << endl; }
};
这样，当执行：
n1->_next = n2; // 因为是weak_ptr，所以n2的引用计数还是1（weak_ptr的赋值不会增加shared_ptr的引用计数）
n2->_prev = n1; // 同理，n1的引用计数还是1
在main函数结束时：
n2析构，引用计数减1变为0，于是释放n2指向的对象，在释放n2对象时，其成员_prev（weak_ptr）也会被销毁，但这不会影响n1的引用计数。
n1析构，引用计数减1变为0，于是释放n1指向的对象。
因此，使用weak_ptr打破了循环引用。
注意：weak_ptr只能指向由shared_ptr管理的对象，并且不会影响其生命周期。当需要访问对象时，可以通过lock()函数获得一个shared_ptr
8.1 为什么使用shared_ptr会导致闭环呢？
还是上面的那个代码，如果按照上面的那个例子：
大家看我上面的这个图，很好，这样就形成了一个闭环。谁也降服不了谁。主要问题还是引用计数的问题！
所以，解决办法就是上面我写的：把ListNode结构体中的_next和_prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的 引用计数，_next和_prev不参与资源释放管理逻辑，就成功打破了循环引用，解决了这里的问题
9.weak_ptr
9.1 weak_ptr的使用：
老说这个weak_ptr可以解决上面的这个问题，那这个到底是何方神圣？weak_ptr:弱指针。
咱们上面说的RAII，它并不遵守。weak_ptr不支持RAII，也不支持访问资源，所以我们看文档发现weak_ptr构造时不支持绑定到资 源，只支持绑定到shared_ptr，绑定到shared_ptr时，不增加shared_ptr的引用计数，那么就可以 解决上述的循环引用问题。
所以他的构造不像上面那两个一样，采用指针接收的方法。
都是，要么是空，要么是引用接收。
weak_ptr也没有重载operator*和operator->等，因为他不参与资源管理，那么如果他绑定的 shared_ptr已经释放了资源，那么他去访问资源就是很危险的。weak_ptr支持expired检查指向的 资源是否过期，use_count也可获取shared_ptr的引用计数，weak_ptr想访问资源时，可以调用 lock返回⼀个管理资源的shared_ptr，如果资源已经被释放，返回的shared_ptr是⼀个空对象，如 果资源没有释放，则通过返回的shared_ptr访问资源是安全的 。
大家来看一个例子就差不多明白了：
int main()
{
std::shared_ptr<string> sp1(new string("111111"));//创建一个shared_ptr，管理一个string对象，内容为"111111"。引用计数为1。
std::shared_ptr<string> sp2(sp1);//通过拷贝构造，sp2和sp1共享同一个对象，引用计数变为2。
std::weak_ptr<string> wp = sp1;//创建一个weak_ptr wp，它观察sp1所管理的对象。注意，weak_ptr的创建不会增加引用计数，所以引用计数还是2。
cout << wp.expired() << endl;//expired()返回weak_ptr是否过期（即它观察的对象是否已经被释放）。此时对象还在，所以返回false（0）。
cout << wp.use_count() << endl;//返回与weak_ptr共享对象的shared_ptr的数量，即引用计数，这里应该是2。
// sp1和sp2都指向了其他资源，则weak_ptr就过期了
sp1 = make_shared<string>("222222");//sp1被重新赋值，指向一个新的string对象（内容为"222222"）。这样，原来的对象引用计数减1（变为1），因为sp2还指向它。wp仍然观察原来的对象。
cout << wp.expired() << endl;//因为原来的对象还没有被释放（sp2还指向它），所以返回false（0）。
cout << wp.use_count() << endl;//现在，原来的对象的引用计数是1（只有sp2指向它），所以这里输出1。
sp2 = make_shared<string>("333333");//sp2也被重新赋值，指向一个新的string对象（内容为"333333"）。这样，原来的对象引用计数再减1变为0，于是被释放。
cout << wp.expired() << endl;//因为原来的对象已经被释放，所以wp过期，返回true（1）。
cout << wp.use_count() << endl;//此时，wp观察的对象已经释放，引用计数为0，所以输出0。
wp = sp1;//将wp重新指向sp1当前管理的对象（即内容为"222222"的对象）。
//std::shared_ptr<string> sp3 = wp.lock();
/*lock()：获取共享指针
shared_ptr<T> lock() const noexcept;
返回一个管理被观察对象的 shared_ptr
对象有效时：增加引用计数
对象无效时：返回空的 shared_ptr*/
auto sp3 = wp.lock();//通过lock()函数，wp尝试获取一个shared_ptr。因为sp1管理的对象还存在（引用计数至少为1），所以lock()返回一个有效的shared_ptr（sp3），此时引用计数增加1（sp1和sp3，所以引用计数为2）。
cout << wp.expired() << endl;//现在wp观察的对象是sp1管理的对象，它还存在，所以返回false（0）。
cout << wp.use_count() << endl;//返回当前共享对象的shared_ptr个数，即引用计数，应该是2（sp1和sp3）。
*sp3 += "###";//通过sp3修改字符串，在字符串末尾追加"###"。
cout << *sp1 << endl;//输出sp1指向的字符串，由于sp1和sp3指向同一个对象，所以输出的是修改后的字符串："222222###"。
return 0;
}大家要细细的观摩上面代码。你不仅会巩固之前的只是，还能够对weak_ptr理解更深。
9.2 weak_ptr的原理代码：（底层）
// 需要注意的是我们这⾥实现的shared_ptr和weak_ptr都是以最简洁的⽅式实现的，
// 只能满⾜基本的功能，这⾥的weak_ptr lock等功能是⽆法实现的，想要实现就要
// 把shared_ptr和weak_ptr⼀起改了，把引⽤计数拿出来放到⼀个单独类型，shared_ptr
// 和weak_ptr都要存储指向这个类的对象才能实现，有兴趣可以去翻翻源代码
template<class T>
class weak_ptr
{
public:
weak_ptr()// 默认构造空指针
{}
// 从 shared_ptr 构造
weak_ptr(const shared_ptr<T>& sp)
:_ptr(sp.get())// 获取但不增加引用计数
{}
// 从 shared_ptr 赋值
weak_ptr<T>& operator=(const shared_ptr<T>& sp)
{
_ptr = sp.get();// 获取指针但不增加计数
return *this;
}
private:
T* _ptr = nullptr;// 观察的指针（不管理生命周期）
};10.C++11和boost中智能指针的关系
Boost库是为C++语言标准库提供扩展的⼀些C++程序库的总称，Boost社区建立的初衷之⼀就是为 C++的标准化工作提供可供参考的实现，Boost社区的发起⼈Dawes本⼈就是C++标准委员会的成员 之⼀。在Boost库的开发中，Boost社区也在这个方向上取得了丰硕的成果，C++11及之后的新语法 和库有很多都是从Boost中来的。
1. C++98中产生了第⼀个智能指针auto_ptr。
2. C++boost给出了更实用的scoped_ptr/scoped_array和shared_ptr/shared_array和weak_ptr等.
3. C++TR1，引入了shared_ptr等，不过注意的是TR1并不是标准版。
4. C++11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的 scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。
11.内存泄漏
11.1 什么是内存泄漏，内存泄漏的危害
什么是内存泄漏：内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存，⼀般是忘记释 放或者发生异常释放程序未能执行导致的。内存泄漏并不是指内存在物理上的消失，而是应用程序分 配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。
内存泄漏的危害：普通程序运行⼀会就结束了出现内存泄漏问题也不大，进程正常结束，页表的映射 关系解除，物理内存也可以释放。长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服 务、长时间运行的客户端等等，不断出现内存泄漏会导致可用内存不断变少，各种功能响应越来越 慢，最终卡死。
int main()
{
// 申请一个1G未释放，这个程序多次运行也没啥危害
// 因为程序马上就结束，进程结束各种资源也就回收了
char* ptr = new char[1024 * 1024 * 1024];
cout << (void*)ptr << endl;return 0;
}
11.2 如何避免内存泄漏
⼯程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理 想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下⼀条智能指针来管理 才有保证。
1. 尽量使用智能指针来管理资源，如果自己场景比较特殊，采用RAII思想自己造个轮子管理。
2. 定期使用内存泄漏工具检测，尤其是每次项目快上线前，不过有些工具不够靠谱，或者是收费。 3. 总结⼀下：内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错 型。如泄漏检测工具。
OK，本篇完，........................................