目录1. 智能指针的使用场景分析2. RAII和智能指针的设计思路3. C标准库智能指针的使用auto_ptr、unique_ptr、shared_ptr、weak_ptr4. 智能指针的原理5. shared_ptr和weak_ptr5.1 shared_ptr循环引用问题5.2 weak_ptr6. shared_ptr的线程安全问题7. C11和boost中智能指针的关系8. 内存泄漏8.1 什么是内存泄漏内存泄漏的危害8.2 如何检测内存泄漏了解8.3 如何避免内存泄漏9. 智能指针大白话说明9.1 智能指针简介9.2 智能指针的定义和使用1. unique_ptr2. shared_ptr3. weak_ptr9.3 weak_ptr 解决 shared_ptr 循环引用1. 怎么解决9.4 shared_ptr 和make_shared 的区别1. 智能指针的使用场景分析下面程序中我们可以看到new了以后我们也delete了但是因为抛异常导后面的delete没有得到执行所以就内存泄漏了所以我们需要new以后捕获异常捕获到异常后delete内存再把异常抛出但是因为new本身也可能抛异常连续的两个new和下面的Divide都可能会抛异常让我们处理起来很麻烦。智能指针放到这样的场景里面就让问题简单多了。#includeiostream using namespace std; double Divide(int a, int b) { // 当b 0时抛出异常 if (b 0) { throw Divide by zero condition!; } else { return (double)a / (double)b; } } void Func() { // 这里可以看到如果发生除0错误抛出异常另外下面的array1和array2没有得到释放。 // 所以这里捕获异常后并不处理异常异常还是交给外面处理这里捕获了再重新抛出去。 // 但是如果array2 new的时候抛异常呢就还需要套一层捕获释放逻辑这里更好解决方案 // 是智能指针否则代码太挫了 int* array1 new int[10]; int* array2 new int[10]; // 抛异常呢,处理很复杂 try { int len, time; cin len time; cout Divide(len, time) endl; } catch (...) // 如果抛异常则要再catch里面进行delete[] { cout delete [] array1 endl; cout delete [] array2 endl; delete[] array1; delete[] array2; throw; // 异常重新抛出捕获到什么抛出什么 } // 如果没抛异常则delete[] 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; }2. RAII和智能指针的设计思路•RAII是Resource Acquisition Is Initialization的缩写他是一种管理资源的类的设计思想本质是一种利用对象生命周期来管理获取到的动态资源避免资源泄漏这里的资源可以是内存、文件指针、网络连接、互斥锁等等。RAII在获取资源时把资源委托给一个对象接着控制对资源的访问资源在对象的生命周期内始终保持有效最后在对象析构的时候释放资源这样保障了资源的正常释放避免资源泄漏问题。• 智能指针类除了满足RAII的设计思路还要方便资源的访问所以智能指针类还会想迭代器类一样重载operator*/operator-/operator[] 等运算符方便访问资源。#includeiostream using namespace std; double Divide(int a, int b) { // 当b 0时抛出异常 if (b 0) { throw Divide by zero condition!; } else { return (double)a / (double)b; } } templateclass T class SmartPtr { public: // RAII SmartPtr(T* ptr) :_ptr(ptr) {} ~SmartPtr() { cout delete[] _ptr endl; delete[] _ptr; } // 重载运算符模拟指针的行为方便访问资源 T operator*() { return *_ptr; } T* operator-() { return _ptr; } T operator[](size_t i) { return _ptr[i]; } private: T* _ptr; }; void Func() { // 这里可以看到如果发生除0错误抛出异常另外下面的array和array2没有得到释放。 // 所以这里捕获异常后并不处理异常异常还是交给外面处理这里捕获了再重新抛出去。 // 但是如果array2 new的时候抛异常呢就还需要套一层捕获释放逻辑这里更好解决方案 // 是智能指针否则代码太戳了 // 在这里用只能指针来管理资源。 SmartPtrint sp1 new int[10]; SmartPtrint sp2 new int[10]; // 抛异常呢 SmartPtrint sp3 new int[10]; // 抛异常呢 SmartPtrint sp4 new int[10]; // 抛异常呢 SmartPtrpairint, int sp5 new pairint, int[10]; // 抛异常呢 int len, time; cin len time; cout Divide(len, time) endl; sp1[5] 50; sp5-first 1; sp5-second 2; cout sp1[5] 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; }3. C标准库智能指针的使用auto_ptr、unique_ptr、shared_ptr、weak_ptr• C标准库中的智能指针都在memory这个头文件下面我们包含memory就可以是使用了智能指针有好几种除了weak_ptr他们都符合RAII和像指针一样访问的行为原理上而言主要是解决智能指针拷贝时的思路不同。•auto_ptr是C98时设计出来的智能指针他的特点是拷贝时把被拷贝对象的资源的管理权转移给拷贝对象这是一个非常糟糕的设计因为他会到被拷贝对象悬空访问报错的问题C11设计出新的智能指针后强烈建议不要使用auto_ptr。其他C11出来之前很多公司也是明令禁止使用这个智能指针的。•unique_ptr是C11设计出来的智能指针他的名字翻译出来是唯一指针他的特点的不支持拷贝把拷贝构造和拷贝赋值delete掉只支持移动。如果不需要拷贝的场景就非常建议使用他。•shared_ptr是C11设计出来的智能指针他的名字翻译出来是共享指针他的特点是支持拷贝也支持移动。如果需要拷贝的场景就需要使用他了。底层是用引用计数的方式实现的。•weak_ptr是C11设计出来的智能指针他的名字翻译出来是弱指针他完全不同于上面的智能指针他不支持RAII也就意味着不能用它直接管理资源weak_ptr的产生本质是要解决shared_ptr的一个循环引用导致内存泄漏的问题。具体细节下面我们再细讲。•智能指针析构时默认是进行delete释放资源这也就意味着如果不是new出来的资源交给智能指针管理析构时就会崩溃。智能指针支持在构造时给一个删除器所谓删除器本质就是一个可调用对象这个可调用对象中实现你想要的释放资源的方式当构造智能指针时给了定制的删除器在智能指针析构时就会调用删除器去释放资源。特殊的因为new[]经常使用所以为了简洁一点unique_ptr 和 shared_ptr 都特化了一份[]的版本。所以要管理new []的资源使用时要用以下方式unique_ptrDate[] up1(new Date[5]); shared_ptrDate[] sp1(new Date[5]);• template class T, class... Args shared_ptrT make_shared (Args... args);• shared_ptr 除了支持用指向资源的指针构造还支持 make_shared 用初始化资源对象的值直接构造。• shared_ptr 和 unique_ptr 都支持了operator bool的类型转换如果智能指针对象是一个空对象没有管理资源则返回false否则返回true意味着我们可以直接把智能指针对象给if判断是否为空。• shared_ptr 和 unique_ptr 都得构造函数都使用explicit 修饰防止普通指针隐式类型转换成智能指针对象。示例1auto_ptr、unique_ptr、shared_ptr、weak_ptr的使用#includeiostream using namespace std; 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_ptrDate ap1(new Date); // 1.auto_ptr拷贝时管理权限转移被拷贝对象ap1悬空 auto_ptrDate ap2(ap1); // 空指针访问ap1对象已经悬空 //ap1-_year; // 2.unique_ptr不支持拷贝,但支持移动 unique_ptrDate up1(new Date); //unique_ptrDate up2(up1); // 支持移动但是移动后up1也悬空所以使用移动要谨慎 //unique_ptrDate up3(move(up1)); // 3.shared_ptr支持拷贝也支持移动底层是用引用计数的方式实现的。 shared_ptrDate sp1(new Date); // 支持拷贝 shared_ptrDate sp2(sp1); shared_ptrDate sp3(sp2); cout sp1.use_count() endl; sp1-_year; cout sp1-_year endl; cout sp2-_year endl; cout sp3-_year endl; return 0; }示例2定制删除器#includeiostream #includememory using namespace std; 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; } }; // 函数指针做删除器 templateclass T void DeleteArrayFunc(T* ptr) { delete[] ptr; } // 仿函数定制删除器 templateclass 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_ptrDate up1(new Date[10]); // shared_ptrDate sp1(new Date[10]); // 解决方案1 // 因为new[]经常使用所以unique_ptr和shared_ptr // 实现了一个特化版本这个特化版本析构时用的delete[] unique_ptrDate[] up1(new Date[5]); shared_ptrDate[] sp1(new Date[5]); // 解决方案2:定制删除器 // unique_ptr和shared_ptr支持删除器的方式有所不同 // unique_ptr是在类模板参数支持的shared_ptr是构造函数参数支持的 // 这里没有使用相同的方式还是挺坑的 // 使用仿函数unique_ptr可以不在构造函数传递因为仿函数类型构造的对象直接就可以调用 // 但是下面的函数指针和lambda的类型不可以 // 仿函数对象做删除器(unique_ptr两种方式调用删除器都可以) unique_ptrDate, DeleteArrayDate up2(new Date[5]); unique_ptrDate, DeleteArrayDate upp2(new Date[5], DeleteArrayDate()); shared_ptrDate sp2(new Date[5], DeleteArrayDate()); // 函数指针做删除器 unique_ptrDate, void(*)(Date*) up3(new Date[5], DeleteArrayFuncDate); shared_ptrDate sp3(new Date[5], DeleteArrayFuncDate); // lambda表达式做删除器 auto delArrOBJ [](Date* ptr) {delete[] ptr; }; unique_ptrDate, decltype(delArrOBJ) up4(new Date[5], delArrOBJ); shared_ptrDate sp4(new Date[5], delArrOBJ); // 实现其他资源管理的删除器 shared_ptrFILE sp5(fopen(Test.cpp, r), Fclose()); shared_ptrFILE sp6(fopen(Test.cpp, r), [](FILE* ptr) { cout fclose: ptr endl; fclose(ptr); }); return 0; } // 总结 // share_ptr定制删除器 都可以相对建议lambda // unique_ptr定制删除器 建议仿函数示例3make_shared的使用int main() { std::shared_ptrDate sp1(new Date(2024, 9, 11)); shared_ptrDate sp2 make_sharedDate(2024, 9, 11); shared_ptrDate sp4; // if (sp1.operator bool()) if (sp1) cout sp1 is not nullptr endl; //if (!sp4) if (!sp4.operator bool()) cout sp4 is nullptr endl; // 不支持类型转换优化 //shared_ptrDate sp5 new Date(2024, 9, 11); //unique_ptrDate sp6 new Date(2024, 9, 11); return 0; }4. 智能指针的原理• 下面我们模拟实现了auto_ptr和unique_ptr的核心功能这两个智能指针的实现比较简单大家了解一下原理即可。auto_ptr的思路是拷贝时转移资源管理权给被拷贝对象这种思路是不被认可的也不建议使用。unique_ptr的思路是不支持拷贝。• 大家重点要看看shared_ptr是如何设计的尤其是引用计数的设计主要这里一份资源就需要一个引用计数所以引用计数采用静态成员的方式是无法实现的要使用堆上动态开辟的方式构造智能指针对象时来一份资源就要new一个引用计数出来。多个shared_ptr指向资源时就引用计数shared_ptr对象析构时就--引用计数引用计数减到0时代表当前析构的shared_ptr是最后一个管理资源的对象则析构资源。#includeiostream #includememory #includefunctional #includeatomic #includethread #includemutex using namespace std; 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; } }; namespace csdn { templateclass T class shared_ptr { public: shared_ptr(T* ptr) : _ptr(ptr) , _pcount(new atomicint(1)) {} templateclass D shared_ptr(T* ptr, D del) : _ptr(ptr) , _pcount(new atomicint(1)) , _del(del) {} ~shared_ptr() { if (--(*_pcount) 0) { //delete _ptr; _del(_ptr); delete _pcount; } } shared_ptr(const shared_ptrT sp) : _ptr(sp._ptr) , _pcount(sp._pcount) { (*_pcount); } // sp1 sp4;要考虑自己给自己赋值 shared_ptrT operator(const shared_ptrT sp) { //if (this ! sp) if (_ptr ! sp._ptr) { if (--(*_pcount) 0) { delete _ptr; delete _pcount; } _pcount sp._pcount; _ptr sp._ptr; (*_pcount); } return *this; } T operator*() { return *_ptr; } T* operator-() { return _ptr; } int use_count() { return *_pcount; } private: T* _ptr; //int* _pcount; atomicint* _pcount; // 原子操作 functionvoid(T*) _del [](T* ptr) {delete ptr; }; }; // 需要注意的是我们这里实现的shared_ptr和weak_ptr都是以最简洁的方式实现的 // 只能满足基本的功能这里的weak_ptr lock等功能是无法实现的想要实现就要 // 把shared_ptr和weak_ptr一起改了把引用计数拿出来放到一个单独类型shared_ptr // 和weak_ptr都要存储指向这个类的对象才能实现有兴趣可以去翻翻源代码 templateclass T class weak_ptr { public: weak_ptr() {} weak_ptr(const shared_ptrT sp) :_ptr(sp.get()) {} weak_ptrT operator(const shared_ptrT sp) { _ptr sp.get(); return *this; } private: T* _ptr nullptr; }; } int main() { csdn::shared_ptrDate sp1(new Date); csdn::shared_ptrDate sp2(sp1); // 拷贝构造 csdn::shared_ptrDate sp3 sp2; csdn::shared_ptrDate sp4(new Date); sp1-_year; sp3-_month; // 赋值拷贝 //sp1 sp4; sp4 sp4; sp1 sp2; return 0; }5. shared_ptr和weak_ptr5.1 shared_ptr循环引用问题• shared_ptr大多数情况下管理资源非常合适支持RAII也支持拷贝。但是在循环引用的场景下会导致资源没得到释放内存泄漏所以我们要认识循环引用的场景和资源没释放的原因并且学会使用weak_ptr解决这种问题。• 如下图所述场景n1和n2析构后管理两个节点的引用计数减到11. 右边的节点什么时候释放呢左边节点中的_next管着呢_next析构后右边的节点就释放了。2. _next什么时候析构呢_next是左边节点的的成员左边节点释放_next就析构了。3. 左边节点什么时候释放呢左边节点由右边节点中的_prev管着呢_prev析构后左边的节点就释放了。4. _prev什么时候析构呢_prev是右边节点的成员右边节点释放_prev就析构了。•至此逻辑上成功形成回旋镖似的循环引用谁都不会释放就形成了循环引用导致内存泄漏。• 把ListNode结构体中的_next和_prev改成weak_ptrweak_ptr绑定到shared_ptr时不会增加它的引用计数_next和_prev不参与资源释放管理逻辑就成功打破了循环引用解决了这里的问题。示例循环引用使用weak_ptr解决struct ListNode { int _data; // ListNode* _next; // ListNode* _prev; // std::shared_ptrListNode _next; // std::shared_ptrListNode _prev; // 这里改成weak_ptr当n1-_next n2;绑定shared_ptr时 // 不增加n2的引用计数不参与资源释放的管理就不会形成循环引用了 std::weak_ptrListNode _next; std::weak_ptrListNode _prev; ~ListNode() { cout ~ListNode() endl; } }; int main() { // 循环引用 -- 内存泄露 std::shared_ptrListNode n1(new ListNode); std::shared_ptrListNode 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; }5.2 weak_ptr• 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访问资源是安全的。示例weak_ptr检查指向的share_ptr是否过期。int main() { std::shared_ptrstring sp1(new string(111111)); std::shared_ptrstring sp2(sp1); std::weak_ptrstring wp sp1; cout wp.expired() endl; // expired()判断weak_ptr是否过期 cout wp.use_count() endl; // sp1和sp2都指向了其他资源则weak_ptr就过期了 sp1 make_sharedstring(222222); cout wp.expired() endl; cout wp.use_count() endl; sp2 make_sharedstring(333333); cout wp.expired() endl; cout wp.use_count() endl; // 到此处weak_ptr指向的内容过期wp.expired()输出1 wp sp1; //std::shared_ptrstring sp3 wp.lock(); auto sp3 wp.lock(); // lock()返回一个share_ptr,从此就算sp1释放wp还有保底的sp3保证不会过期 cout wp.expired() endl; cout wp.use_count() endl; *sp3 ###; cout *sp1 endl; return 0; }6. shared_ptr的线程安全问题• shared_ptr的引用计数对象在堆上如果多个shared_ptr对象在多个线程中进行shared_ptr的拷贝析构时会访问修改引用计数就会存在线程安全问题所以shared_ptr引用计数是需要加锁或者原子操作保证线程安全的。• shared_ptr指向的对象也是有线程安全的问题的但是这个对象的线程安全问题不归shared_ptr管它也管不了应该有外层使用shared_ptr的人进行线程安全的控制。• 下面的程序会崩溃或者A资源没释放bit::shared_ptr引用计数从int*改成atomicint*就可以保证引用计数的线程安全问题或者使用互斥锁加锁也可以。shared_ptr自身是线程安全的它里面的引用计数是加锁的指向的资源不是线程安全的需要加锁。​ struct AA { int _a1 0; int _a2 0; ~AA() { cout ~AA() endl; } }; int main() { csdn::shared_ptrAA p(new AA); const size_t n 100000; mutex mtx; auto func []() { for (size_t i 0; i n; i) { // 这里智能指针拷贝会计数 csdn::shared_ptrAA copy(p); { unique_lockmutex 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; } ​7. C11和boost中智能指针的关系• Boost库是为C语言标准库提供扩展的一些C程序库的总称Boost社区建立的初衷之一就是为C的标准化工作提供可供参考的实现Boost社区的发起人Dawes本人就是C标准委员会的成员之一。在Boost库的开发中Boost社区也在这个方向上取得了丰硕的成果C11及之后的新语法和库有很多都是从Boost中来的。• C 98 中产生了第一个智能指针auto_ptr。• C boost给出了更实用的scoped_ptr/scoped_array和shared_ptr/shared_array和weak_ptr等.• C TR1引入了shared_ptr等不过注意的是TR1并不是标准版。• C 11引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。8. 内存泄漏8.1 什么是内存泄漏内存泄漏的危害什么是内存泄漏内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存一般是忘记释放或者发生异常释放程序未能执行导致的。内存泄漏并不是指内存在物理上的消失而是应用程序分配某段内存后因为设计错误失去了对该段内存的控制因而造成了内存的浪费。内存泄漏的危害普通程序运行一会就结束了出现内存泄漏问题也不大进程正常结束页表的映射关系解除物理内存也可以释放。长期运行的程序出现内存泄漏影响很大如操作系统、后台服务、长时间运行的客户端等等不断出现内存泄漏会导致可用内存不断变少各种功能响应越来越慢最终卡死。int main() { // 申请一个1G未释放这个程序多次运行也没啥危害 // 因为程序马上就结束进程结束各种资源也就回收了 char* ptr new char[1024 * 1024 * 1024]; cout (void*)ptr endl; return 0; }8.2 如何检测内存泄漏了解• linux下内存泄漏检测• windows下使用第三方工具8.3 如何避免内存泄漏• 工程前期良好的设计规范养成良好的编码规范申请的内存空间记着匹配的去释放。ps这个理想状态。但是如果碰上异常时就算注意释放了还是可能会出问题。需要下一条智能指针来管理才有保证。• 尽量使用智能指针来管理资源如果自己场景比较特殊采用RAII思想自己造个轮子管理。• 定期使用内存泄漏工具检测尤其是每次项目快上线前不过有些工具不够靠谱或者是收费。• 总结一下内存泄漏非常常见解决方案分为两种1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。9. 智能指针大白话说明9.1 智能指针简介C 中普通指针使用new申请内存后需要自己deleteint* p new int(10); // 使用 p delete p;问题是我们很容易忘记delete p;一旦忘记就可能造成内存泄漏。智能指针就是让一个对象帮你管理普通指针当这个智能指针不再使用时它会自动释放管理的内存。可以大白话理解成普通指针 你借了东西你自己记得还。 智能指针 找了一个管家。 东西交给管家管理管家不用了以后会自动归还。智能指针定义在#include memoryC 常用的智能指针有三个智能指针大白话理解unique_ptr这个对象只能由一个人拥有shared_ptr这个对象可以由多个人共同拥有weak_ptr我认识这个对象但我不拥有它9.2 智能指针的定义和使用1. unique_ptrunique_ptr表示一个对象只能有一个拥有者。推荐使用auto p std::make_uniqueint(10);使用方式和普通指针差不多cout *p endl; // 10对于类class Person { public: void Show() { cout hello endl; } }; auto p std::make_uniquePerson(); p-Show();因为只能一个人拥有所以不能直接复制auto p1 std::make_uniqueint(10); auto p2 p1; // ❌ 不允许但是可以把所有权转移给别人auto p2 std::move(p1);可以理解成原来 p1 ───→ 对象 std::move(p1) 后用于构造 p2 转移后 p1 对象 ↑ p2 ──────┘这里的std::move(p1)并不是直接把p1里面的资源搬走而是把原本是左值的p1转换成右值表达式告诉编译器“这个对象的资源可以被转移了”。随后unique_ptr的移动构造函数接管p1管理的对象把所有权转移给p2因此移动完成后p2拥有原来的对象而p1通常会变成空指针。也就是unique_ptr不是“共享”而是“把管理权交出去”。2. shared_ptrshared_ptr表示一个对象可以由多个智能指针共同拥有。创建auto p1 std::make_sharedint(10);可以直接复制auto p2 p1;这时候p1 ──┐ ├──→ int对象 p2 ──┘shared_ptr内部会维护一个引用计数。刚创建auto p1 std::make_sharedint(10);相当于p1 ───→ 对象 引用计数 1再复制auto p2 p1;变成p1 ──┐ ├──→ 对象 p2 ──┘ 引用计数 2如果p2.reset();变成p1 ───→ 对象 引用计数 1等所有shared_ptr都不再拥有这个对象引用计数 0对象就会自动销毁。所以shared_ptr靠引用计数判断什么时候释放对象。可以使用cout p1.use_count() endl;查看当前有多少个shared_ptr共同拥有对象。3. weak_ptrweak_ptr一般配合shared_ptr使用。例如auto sp std::make_sharedint(10); std::weak_ptrint wp sp;此时sp ─────→ 对象 shared_ptr拥有对象 wp ------ 对象 weak_ptr只是观察对象最关键的是weak_ptr不会增加引用计数。例如auto sp std::make_sharedint(10); std::weak_ptrint wp sp; cout sp.use_count();仍然是1而不是2。因为wp并不拥有这个对象。weak_ptr不能直接*wp; // ❌ wp-xxx(); // ❌因为它无法保证对象还活着。需要先auto p wp.lock();如果对象还存在if (auto p wp.lock()) { cout *p endl; }lock()会临时获得一个shared_ptr。可以理解成weak_ptr我知道你住哪但我不知道你现在还在不在家。lock()我先去看看你还在不在。9.3weak_ptr解决shared_ptr循环引用这是weak_ptr最重要的用途之一。假设有两个类class A; class B; class A { public: std::shared_ptrB pb; }; class B { public: std::shared_ptrA pa; };然后auto a std::make_sharedA(); auto b std::make_sharedB(); a-pb b; b-pa a;这时候形成A ──shared_ptr──→ B ↑ │ │ │ └──shared_ptr────┘也就是A 说“B 是我的我拥有 B。”B 说“A 是我的我也拥有 A。”于是两个人互相拉着。假设外面的a b都销毁了。按理说 A 和 B 应该销毁。但是A里面还有 shared_ptr 指着B B里面还有 shared_ptr 指着A所以A还有人拥有我我不能死。 B还有人拥有我我也不能死。于是A 不释放 B 不释放造成循环引用 → 引用计数永远无法变成 0 → 内存泄漏。1. 怎么解决把其中一边改成weak_ptrclass A { public: std::shared_ptrB pb; }; class B { public: std::weak_ptrA pa; };现在A ──shared_ptr──→ B ↑ │ │ │ └───weak_ptr─────┘关系变成A我拥有 B。B我只是认识 A但我不拥有 A。因为weak_ptr不会增加 A 的引用计数。这样外面的shared_ptr消失之后就可以正常释放。所以解决循环引用的本质不是weak_ptr有什么特殊的释放能力。而是weak_ptr根本不参与引用计数所以把 shared_ptr 形成的“环”打断了。最后可以这样记unique_ptr ↓ 独占 只能一个人拥有 shared_ptr ↓ 共享 多个人可以共同拥有 通过引用计数决定何时释放 weak_ptr ↓ 观察 可以找到 shared_ptr 管理的对象 但不增加引用计数最核心的一句话unique_ptr 我一个人拥有shared_ptr 大家一起拥有weak_ptr 我只是认识你不拥有你。而循环引用shared_ptr ↔ shared_ptr容易导致双方谁也释放不了。改成shared_ptr → 对方 ↑ weak_ptr就把循环引用打断了。9.4 shared_ptrint和make_sharedint的区别std::make_sharedint和std::shared_ptrint不是同一种东西。std::shared_ptrint是一个类型表示“管理int对象的共享智能指针”。std::make_sharedint是一个函数模板用来创建int对象并返回一个shared_ptrint。例如std::shared_ptrint p1 std::make_sharedint(10);这里std::shared_ptrint表示变量p1的类型。而std::make_sharedint(10)表示创建一个值为10的int对象并返回管理它的shared_ptrint。也可以不用make_sharedstd::shared_ptrint p2(new int(10));这同样能创建shared_ptrint。所以可以简单理解成shared_ptrint ↓ 智能指针的类型 make_sharedint(10) ↓ 帮你创建对象并返回 shared_ptrint例如auto p std::make_sharedint(10);这里auto推导出来的类型就是std::shared_ptrint通常更推荐auto p std::make_sharedint(10);而不是std::shared_ptrint p(new int(10));因为make_shared写法更简洁而且通常会把对象和引用计数控制块一起分配效率更好。一句话记忆shared_ptrint是“智能指针类型”make_sharedint()是“创建这种智能指针的工具”。