当前位置：首页 > news >正文

C++智能指针（详细解答）

news 来源：原创 2025/6/18 11:45:10

1.为什么要使用智能指针？

2.RAII和智能指针的设计思路

3.删除器

4.auto_ptr

4.1 auto_ptr的使用

4.2 auto_ptr的原理

5.unique_ptr

5.1 unique_ptr的使用：

5.2 unique_ptr的原理：

6.shared_ptr

6.1 shared_ptr的使用：

6.2 make_shared

6.3 shared_ptr的使用原理：

7.shared_ptr的线程安全问题

8.shared_ptr循环引用问题

8.1 为什么使用shared_ptr会导致闭环呢？

9.weak_ptr

9.1 weak_ptr的使用：

9.2 weak_ptr的原理代码：（底层）

10.C++11和boost中智能指针的关系

11.内存泄漏

11.1 什么是内存泄漏，内存泄漏的危害

11.2 如何避免内存泄漏

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 = sp3shared_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;
}