『 C++ 入门到放弃 』- 智能指针
一、智能指针
在 C++ 中，指针是存储内存地址的变量。广泛用于动态内存定位，用于存储已分配内存的地址。但同时指针也带来了很多问题
double Divide(int a, int b) {// 当b == 0时抛出异常if (b == 0) {throw "Divide by zero condition!";} else {return (double)a / (double)b;} } void Func() {// 如果array2 new的时候抛异常呢，就还需要套⼀层捕获释放逻辑，这⾥更好解决⽅案是智能指针，否则代码太杂了int *array1 = new int[10];int *array2 = new int[10]; // 抛异常呢？那array1就会发生内存泄漏/* --- 过于重复int *array1 = nullptr;int *array2 = nullptr;try {array1 = new int[10];} catch (...) {// array1 分配失敗，沒有資源需要釋放throw;}try {array2 = new int[10];} catch (...) {// array2 分配失敗，需要釋放 array1delete[] array1;throw;}*/try {int len, time;cin >> len >> time;cout << Divide(len, time) << endl;} catch (...) {// 捕获到Divide的异常要释放 否则会内存泄漏cout << "delete []" << array1 << endl;cout << "delete []" << array2 << endl;delete[] array1;delete[] array2;throw; // 异常重新抛出，捕获到什么抛出什么}// ...cout << "delete []" << array1 << endl;delete[] array1;cout << "delete []" << array2 << endl;delete[] array2; } int main() {try {Func();} catch (const char *errmsg) {cout << errmsg << endl;} catch (const exception &e) {cout << e.what() << endl;} catch (...) {cout << "未知异常" << endl;}return 0; }为什么设计Func捕获到异常后不直接处理而是继续抛异常让上层处理？ — 职责分离原则 (Separation of Concerns)
Func() 的职责是确保资源被正确释放，异常处理的决策权交给调用者 (main())
这样 Func() 不需要知道具体的异常类型或处理策略
如果 Func() 直接处理异常，可能会导致
异常处理逻辑重复 ( 如 new 抛出的异常，也要处理 )
资源清理代码分散
难以维护
为了解决上面的问题就必须的利用智能指针！ ---- 智能指针可以解决内存泄漏的问题
1.1 RAII 与智能指针
RAII是Resource Acquisition Is Initialization的缩写，是⼀种管理资源的类的设计思想，本质是⼀种利⽤对象⽣命周期来管理获取到的动态资源，避免资源泄漏，这⾥的资源可以是内存、⽂件指针、⽹络连接、互斥锁等等。RAII在获取资源时把资源委托给⼀个对象，接着控制对资源的访问，资源在对象的⽣命周期内始终保持有效，最后在对象析构的时候释放资源，这样保障了资源的正常释放，避免资源泄漏问题
智能指针类除了满⾜RAII的设计思路，还要⽅便资源的访问，所以智能指针类还会想迭代器类⼀样
重载 operator*/operator->/operator[] 等运算符，⽅便访问资源
template <class T> class SmartPtr { public:SmartPtr(T *ptr) : _ptr(ptr) {}~SmartPtr() {cout << "~SmartPointer 析构调用" << endl;delete[] _ptr;}T &operator*() { return *_ptr; }T *operator->() { return _ptr; }T &operator[](size_t i) { return _ptr[i]; }private:T *_ptr; };double Divide(int a, int b) {// 当b == 0时抛出异常if (b == 0) {throw "Divide by zero condition!";} else {return (double)a / (double)b;} } void Func() {// 这⾥使⽤RAII的智能指针类管理new出来的数组以后，程序简单多了SmartPtr<int> sp1 = new int[10];SmartPtr<int> sp2 = new int[10];for (size_t i = 0; i < 10; i++) {sp1[i] = sp2[i] = i;}int len, time;cin >> len >> time;cout << Divide(len, time) << endl; } int main() {try {Func();} catch (const char *errmsg) {cout << errmsg << endl;} catch (const exception &e) {cout << e.what() << endl;} catch (...) {cout << "未知异常" << endl;}return 0; }
1.2 C++标准库的智能指针
C++标准库中的智能指针都在 这个头⽂件下⾯，包含 就可以使⽤
智能指针有好⼏种，除了weak_ptr他们都符合RAII和像指针⼀样的访问⾏为，原理上主要是解决智能指针拷⻉时的思路不同
auto_ptr是C++98时设计出来的智能指针，他的特点是拷⻉时把被拷⻉对象的资源的管理权转移给拷⻉对象这是⼀个⾮常糟糕的设计，因为会导致被拷⻉对象悬空，访问报错的问题
C++11设计出新的智能指针后，强烈建议不要使⽤auto_ptr。C++1 1出来之前很多公司也是明令禁⽌使⽤这个智能指针
unique_ptr是C++11设计出来的智能指针，特点是不⽀持拷⻉，只⽀持移动。不需要拷⻉的场景就⾮常建议使⽤它
shared_ptr是C++11设计出来的智能指针，特点是⽀持拷⻉，也⽀持移动。如果需要拷⻉的场景就需要使⽤它了底层是⽤引⽤计数的⽅式实现的
shared_ptr 除了⽀持⽤指向资源的指针构造，还⽀持 make_shared ⽤初始化资源对象的值直接构造
weak_ptr是C++11设计出来的智能指针，它完全不同于上⾯的智能指针，weak_ptr不⽀持RAII，也就意味着不能⽤它直接管理资源，weak_ptr的产⽣本质是要解决shared_ptr的⼀个循环引⽤导致内存泄漏的问题
- shared_ptr 和 unique_ptr 都⽀持operator bool的类型转换，如果智能指针对象是⼀个空对象没有管理资源，则返回false，否则返回true，意味着可以直接把智能指针对象给if判断是否为空
- shared_ptr 和 unique_ptr 的构造函数都使⽤explicit 修饰，防⽌普通指针隐式类型转换成智能指针对象
- 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"));std::shared_ptr<string> sp2(sp1);std::weak_ptr<string> wp = sp1;cout << wp.expired() << endl;cout << wp.use_count() << endl;// sp1和sp2都指向了其他资源，则weak_ptr就过期了sp1 = make_shared<string>("222222");cout << wp.expired() << endl;cout << wp.use_count() << endl;sp2 = make_shared<string>("333333");cout << wp.expired() << endl;cout << wp.use_count() << endl;wp = sp1;//std::shared_ptr<string> sp3 = wp.lock();auto sp3 = wp.lock();cout << wp.expired() << endl;cout << wp.use_count() << endl;*sp3 += "###";cout << *sp1 << endl;return 0; }智能指针析构时默认是进⾏delete释放资源，这也就意味着如果不是new出来的资源，交给智能指针管理，析构时就会崩溃。智能指针⽀持在构造时给⼀个删除器，所谓删除器本质就是⼀个可调⽤对象，这个可调⽤对象中实现你想要的释放资源的⽅式，当构造智能指针时，给了定制的删除器，在智能指针析构时就会调⽤删除器去释放资源
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);// 拷⻉时，管理权限转移，被拷⻉对象ap1悬空// auto_ptr<Date> ap2(ap1);// 空指针访问，ap1对象已经悬空// ap1->_year++;unique_ptr<Date> up1(new Date);// unique_ptr<Date> up2(up1); // 不支持拷贝// 支持移动，但移动后可能导致悬空 => 移动相当于把 up1 的资源转给 up3 管理// unique_ptr<Date> up3(move(up1)); shared_ptr<Date> sp1(new Date);shared_ptr<Date> sp2(sp1); // 支持拷贝shared_ptr<Date> sp3(sp1);cout << sp1.use_count() << endl; // 3sp1->_year++;cout << sp1->_year << endl;cout << sp2->_year << endl;cout << sp3->_year << endl;// ⽀持移动，但是移动后sp1也悬空，所以使⽤移动要谨慎shared_ptr<Date> sp4(move(sp1));return 0; }
1.3 删除器
C++中，删除器是智能指针在释放资源时所使用的函数/函数对象，它负责决定当智能指针销毁时，要怎么释放所管理的对象
- 释放方式可以自定义（不一定用 delete）
- 可以释放非 new 分配的资源（例如 fclose、free等）
unique_ptr 的删除器是在类模版支持的；而shared_ptr 的删除器是在构造函数支持的
/* template<class T, class Deleter = std::default_delete<T>> class unique_ptr; */ 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<Date[]> up1(new Date[5]);shared_ptr<Date[]> sp1(new Date[5]);- C++17 前没有对shared_pt做 []特化*//*解决⽅案2仿函数对象做删除器unique_ptr<Date, DeleteArray<Date>> up2(new Date[5], DeleteArray<Date>());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>()); // 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; }int main() {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<Date> sp4;// if (sp1.operator bool())if (sp1)cout << "sp1 is not nullptr" << endl;if (!sp4)cout << "sp1 is nullptr" << endl;// 报错(因为shared_ptr 和 unique_ptr 不支持隐式转换)shared_ptr<Date> sp5 = new Date(2024, 9, 11);unique_ptr<Date> sp6 = new Date(2024, 9, 11);return 0; }
1.4 shared_ptr 和 weak_ptr
shared_ptr 的问题：循环引用
shared_ptr⼤多数情况下管理资源⾮常合适，⽀持RAII，也⽀持拷⻉。但是在循环引⽤的场景下会导致资源没得到释放内存泄漏，所以我们要认识循环引⽤的场景和资源没释放的原因，并且使⽤weak_ptr解决这种问题
如下图所述场景，n1和n2析构后，管理两个节点的引⽤计数减到1
- 右边的节点什么时候释放呢，左边节点中的 next 管着，next 析构后，右边的节点就释放了
- next什么时候析构呢，next是左边节点的的成员，左边节点释放，next就析构了
- 左边节点什么时候释放呢，左边节点由右边节点中的prev管着呢，prev析构后，左边的节点就释放了
- prev什么时候析构呢，prev是右边节点的成员，右边节点释放，prev就析构了。
⾄此逻辑上成功形成回旋镖似的循环引⽤，谁都不会释放就形成了循环引⽤，导致内存泄漏
把ListNode结构体中的next和prev改成weak_ptr，weak_ptr绑定到shared_ptr时不会增加它的引⽤计数，next和_prev不参与资源释放管理逻辑，就成功打破了循环引⽤，解决了这⾥的问题struct ListNode {int _data;std::shared_ptr<ListNode> _next;std::shared_ptr<ListNode> _prev;// 这⾥改成weak_ptr，当n1->_next = n2;绑定shared_ptr时// 不增加n2的引⽤计数，不参与资源释放的管理，就不会形成循环引⽤了/*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;// weak_ptr不⽀持管理资源，不⽀持RAII// weak_ptr是专⻔绑定shared_ptr，不增加他的引⽤计数，作为⼀些场景的辅助管理// std::weak_ptr<ListNode> wp(new ListNode);return 0; }
1.5 智能指针模拟实现
namespace bit {template <class T> class auto_ptr {public:auto_ptr(T *ptr) : _ptr(ptr) {}auto_ptr(auto_ptr<T> &ptr) {_ptr = ptr._ptr;ptr._ptr = nullptr;}auto_ptr &operator=(auto_ptr<T> &ptr) {if (this != ptr) {if (_ptr) {delete _ptr; // 先释放 不然会有内存泄漏的问题}_ptr = ptr._ptr;ptr._ptr = nullptr;}return *this;}~auto_ptr() {if (_ptr) {cout << "~auto_ptr()" << endl;delete _ptr;}}T &operator*() { return *_ptr; }T *operator->() { return _ptr; }private:T *_ptr;};template <class T> class unique_ptr {public:explicit unique_ptr(T *up) : _ptr(up) {}unique_ptr(T &&up) : _ptr(up) { // 允许移动up.ptr = nullptr;}~unique_ptr() {if (_ptr) {cout << "~unique_ptr()" << endl;delete _ptr;}}T &operator*() { return *_ptr; }T *operator->() { return _ptr; }unique_ptr(const unique_ptr<T> &up) =delete; // 不允许拷贝(连默认拷贝都不能生成)unique_ptr<T> &operator=(const unique_ptr<T> &up) = delete;unique_ptr<T> &operator=(const unique_ptr<T> &&up) {if (_ptr)delete _ptr;_ptr = up._ptr;up._ptr = nullptr;}private:T *_ptr;};template <class T> class shared_ptr {// shared_ptr的实现 --- 指针与引用计数public:explicit shared_ptr(T *sp) : _ptr(sp), p_count(new int(1)) {}~shared_ptr() { release(); }shared_ptr(const shared_ptr<T> &sp) : _ptr(sp._ptr), p_count(sp.p_count) {++(*p_count);}template <class D>shared_ptr(T *ptr, D del) : _ptr(ptr), p_count(new int(1)), _del(del) {}/*如何推出 D步骤一：看你传进来的是什么 你传进来的是 del，它是一个 lambdalambda 在 C++ 里有一个「隐藏的型别」这个型别是编译器自动产生的步骤二：D 就是 del 的型别 编译器看到 D del，就会把 del 的型别当作 D这个型别可以是lambda、函式指标、函式物件，都可以。步骤三：D 会自动推导，不用你写 你不用写 shared_ptr<int, decltype(del)>，只要写 shared_ptr<int>，编译器会自动帮你推导 D*/void release() {if (--(*p_count) == 0) {_del(_ptr);delete p_count;_ptr = nullptr;p_count = nullptr;}}shared_ptr<T> &operator=(shared_ptr<T> &sp) {if (_ptr != sp._ptr) {release();_ptr = sp._ptr;p_count = sp.p_count;_del = sp._del;++(*p_count);}return *this;}T *get() const { return _ptr; }int use_count() const { return *p_count; }T &operator*() { return *_ptr; }T *operator->() { return _ptr; }private:T *_ptr;// 现在的写法会有线程安全的问题/*shared_ptr的引⽤计数对象在堆上，如果多个shared_ptr对象在多个线程中，进⾏shared_ptr的拷⻉析构时会访问修改引 ⽤计数，就会存在线程安全问题，所以shared_ptr引⽤计数是需要加锁或者原⼦操作保证线程安全的解决办法：引⽤计数从int*改成atomic<int>*就可以保证引⽤计数的线程安全问题，或者使⽤互斥锁加锁也可以*///atomic<int>* _pcount;int *p_count; // 计数function<void(T *)> _del = [](T *ptr) { delete 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(const shared_ptr<T> &sp) : _ptr(sp.get()) {}weak_ptr<T> &operator=(const shared_ptr<T> &sp) {_ptr = sp.get();return *this;}private:T *_ptr = nullptr;}; } // namespace bit
1.6 关于内存泄漏
内存泄漏指因为疏忽或错误造成程序未能释放已经不再使⽤的内存，⼀般是忘记释放或者发⽣异常释放程序未能执⾏导致的。内存泄漏并不是指内存在物理上的消失，⽽是应⽤程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因⽽造成了内存的浪费。
内存泄漏的危害：普通程序运⾏⼀会就结束了出现内存泄漏问题也不⼤，进程正常结束，⻚表的映射关系解除，物理内存也可以释放。⻓期运⾏的程序出现内存泄漏，影响很⼤，如操作系统、后台服务、⻓时间运⾏的客⼾端等等，不断出现内存泄漏会导致可⽤内存不断变少，各种功能响应越来越慢，最终卡死
如何避免内存泄漏？
- 尽量使⽤智能指针来管理资源，如果⾃⼰场景⽐较特殊，采⽤RAII思想⾃⼰造个轮⼦管理
- 定期使⽤内存泄漏⼯具检测，尤其是每次项⽬快上线前