📝个人主页🌹：Eternity._    前言：在C++的浩瀚宇宙中，内存管理一直是程序员们必须面对的重要课题。从早期的手动分配与释放，到现代C++标准库中引入的智能指针，每一次进步都标志着C++在提升开发效率、减少错误风险方面的巨大飞跃。智能指针，作为C++11及后续版本中不可或缺的一部分，不仅极大地简化了资源管理，还通过其独特的机制有效防止了内存泄漏和野指针的出现，成为了现代C++编程中不可或缺的工具 本文旨在带领读者深入探索C++智能指针的奥秘，从std::unique_ptr到std::shared_ptr，再到较为特殊的std::weak_ptr，我们将一一剖析这些智能指针的设计理念、使用方法、以及它们背后的原理。通过实例演示和理论解析相结合的方式，帮助读者不仅学会如何正确使用智能指针，更能理解其背后的RAII（Resource Acquisition Is Initialization）资源管理思想，从而在C++编程中更加游刃有余地管理资源 我们将一起踏上探索C++智能指针的奇妙旅程，共同见证它在提升代码质量、保障程序安全方面的巨大力量，让我们携手前行，在C++的编程世界中，共同书写属于自己的辉煌篇章！ 📒1. 智能指针的引入内存方面情景代码示例 (C++)： [code]int div() { int a, b; cin >> a >> b; if (b == 0) { throw invalid_argument("除0错误"); } return a / b; } void Func() { int* p1 = new int; int* p2 = new int; cout << div() << endl; delete p1; cout << "delete p1" << p1 << endl; delete p2; cout << "delete p2" << p2 << endl; } int main() { try { Func(); } catch (exception& e) { cout << e.what() << endl; } return 0; } [/code]当我们正常输入时：程序正常  当我们程序异常终止时：申请的空间并不会被释放  这样就会造成内存泄漏，因此为了能够限制内存泄漏，就有了智能指针 📚2. 智能指针的使用及原理智能指针（Smart Pointers）是现代C++编程中非常重要的一种内存管理技术，旨在解决原始指针使用过程中的内存泄漏、野指针等问题。智能指针是模板类，能够像普通指针一样被操作，但它能在适当的时候自动释放所管理的对象，从而保证资源的正确释放 ⛰️RAIIRAII是一种在C++（以及C++风格的其他编程语言中）常用的资源管理技术。 它的基本思想是：资源的获取在对象的构造时完成，而资源的释放（Release）则在对象的生命周期结束时自动执行，通常是在对象的析构函数中完成。我们实际上把管理一份资源的责任托管给了一个对象，这种方式有助于管理如动态分配的内存、文件句柄、网络连接、互斥锁等需要显式释放的资源 RAII的好处
使用RAII思想设计的SmartPtr类： [code]template<class T> class SmartPtr { public: SmartPtr(T* ptr = nullptr) : _ptr(ptr) {} ~SmartPtr() { cout << "delete -> " << _ptr << endl; delete _ptr; } private: T* _ptr; }; [/code]🌄智能指针的原理但是刚刚的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用 [code]template<class T> class SmartPtr { public: SmartPtr(T* ptr) :_ptr(ptr) {} ~SmartPtr() { cout << "delete -> " << _ptr << endl; delete _ptr; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; }; int main() { SmartPtr<int> sp1(new int); *sp1 = 10 cout<<*sp1<<endl; return 0; } [/code]智能指针的原理：
🌞std::auto_ptrC++98版本的库中就提供了auto_ptr的智能指针 std::auto_ptr文档  auto_ptr的实现原理：管理权转移的思想，我们来简单模拟实现一下它，来了解它的原理 auto_ptr模拟实现 (C++)： [code]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 = nullptr; } return *this; } ~auto_ptr() { if (_ptr) { cout << "delete -> " << _ptr << endl; delete _ptr; _ptr = nullptr; } } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; }; [/code]但是由于auto_ptr存在较严重的问题，很多公司明确要求不能使用 [code]void Test_auto_ptr() { pxt::auto_ptr<int> ap1(new int); pxt::auto_ptr<int> ap2 = ap1; // 管理权转移，导致ap1对象悬空 /*(*ap1)++; (*ap2)++;*/ } [/code]🌙std::unique_ptrC++11中开始提供更靠谱的unique_ptr std::unique_ptr文档文档  unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理 C++11出来之前， unique_ptr模拟实现 (C++)： [code]template<class T> class unique_ptr { public: unique_ptr(T* ptr) :_ptr(ptr) {} ~unique_ptr() { if (_ptr) { cout << "delete -> " << _ptr << endl; delete _ptr; _ptr = nullptr; } } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } // 防拷贝 unique_ptr(auto_ptr<T>& sp) = delete; unique_ptr<T>& operator=(unique_ptr<T>& up) = delete; private: T* _ptr; }; [/code] [code]void Test_unique_ptr() { pxt::unique_ptr<int> up1(new int); //pxt::unique_ptr<int> up2(up1); } [/code]⭐std::shared_ptr与std::weak_ptrC++11中开始提供更靠谱的并且支持拷贝的shared_ptr std::shared_ptr文档文档  shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源
shared_ptr模拟实现 (C++)： [code]template<class T> class shared_ptr { public: shared_ptr(T* ptr = nullptr) :_ptr(ptr) ,_pcount(new int(1)) {} void release() { if (--(*_pcount) == 0) { //cout << "delete -> " << _ptr << endl; delete _ptr; delete _pcount; } } ~shared_ptr() { release(); } shared_ptr(shared_ptr<T>& sp) :_ptr(sp._ptr) , _pcount(sp._pcount) { ++(*_pcount); } // 获取数量 int use_count() const { return *_pcount; } // 获取指针 T* get() const { return _ptr; } shared_ptr<T>& operator=(shared_ptr<T>& sp) { if (_ptr != sp._ptr) { release(); _ptr = sp._ptr; _pcount = sp._pcount; ++(*_pcount); } return *this; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; int* _pcount; }; [/code]强如shared_ptr也会存在一定的问题需要我们解决，我们在使用shared_ptr的时候一定要注意，不能循环引用 [code]struct ListNode { int val; pxt::shared_ptr<ListNode> prev; pxt::shared_ptr<ListNode> next; ~ListNode() { cout << "~ListNode()" << endl; } }; void Test_shared_ptr() { pxt::shared_ptr<ListNode> n1(new ListNode); pxt::shared_ptr<ListNode> n2(new ListNode); cout << n1.use_count() << endl; cout << n2.use_count() << endl; // 循环引用 n1->next = n2; n2->prev = n1; } [/code]  解决方案： 原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数 weak_ptr模拟实现 (C++)： [code]template<class T> class weak_ptr { public: weak_ptr() :_ptr(nullptr) {} weak_ptr(const shared_ptr<T>& sp) :_ptr(sp.get()) {} weak_ptr<T>& operator=(const shared_ptr<T>& sp) { _ptr = sp.get(); return *this; } T& operator*() { return *_ptr; } T* operator->() { return _ptr; } private: T* _ptr; }; [/code]循环引用解决方案： [code]struct ListNode { int val; pxt::weak_ptr<ListNode> prev; pxt::weak_ptr<ListNode> next; ~ListNode() { cout << "~ListNode()" << endl; } }; [/code]删除器 shared_ptr设计了一个删除器来解决一些不是new出来的对象的智能指针管理 仿函数的删除器 (C++)： [code]template<class T> struct DelArray { void operator()(T* ptr) { delete[] ptr; } }; [/code]在增加删除器后，shared_ptr的参数变多了，因此我们还要修改一下shared_ptr的模拟实现 [code]template<class T> class shared_ptr { public: shared_ptr(T* ptr = nullptr) :_ptr(ptr) ,_pcount(new int(1)) {} template<class D> shared_ptr(T* ptr ,D del) : _ptr(ptr) , _pcount(new int(1)) ,_del(del) {} //function<void(T*)> _del; void release() { if (--(*_pcount) == 0) { //cout << "delete -> " << _ptr << endl; //delete _ptr; _del(_ptr); delete _pcount; } } // 其他函数....... private: T* _ptr; int* _pcount; // 提供一个包装器来确定_del的类型 function<void(T*)> _del = [](T* ptr) {delete[] ptr; }; // 提供一个缺省参数，确保在没有提供删除器的情况下能正常使用 }; [/code] [code]void Test_shared_ptr2() { // 定制删除器 pxt::shared_ptr<ListNode> sp1(new ListNode[10], DelArray<ListNode>()); // 也可以通过我们之前学习的Lambda来实现 pxt::shared_ptr<ListNode> sp2(new ListNode[10], [](ListNode* ptr) {delete[] ptr; }); pxt::shared_ptr<ListNode> sp3(new ListNode[10]); [/code]📜3. 内存泄漏内存泄漏：指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费 🍁内存泄漏的危害内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死 内存泄漏的原因： [code]void Function() { // 1.内存申请了忘记释放 int* p1 = (int*)malloc(sizeof(int)); int* p2 = new int; // 2.异常安全问题 int* p3 = new int[10]; Func(); // 如果Func函数抛异常，就会导致 delete[] p3未执行，p3没被释放. delete[] p3; } [/code]🍂内存泄漏的分类与检测 (了解)C/C++程序中一般有两种方面的内存泄漏：
检测内存泄漏： 在windows下使用第三方工具：VLD工具说明 其他工具：内存泄漏工具比较 🌸如何避免内存泄漏
内存泄漏常见解决方案分为两种：
📝4. C++11和boost中智能指针的关系
在C++ 11中，需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的 📖5. 总结随着我们对C++智能指针的深入探索，不难发现，这一特性不仅是C++标准库中的一颗璀璨明珠，更是现代C++编程中不可或缺的基石。通过智能指针，我们不仅能够享受到自动内存管理的便利，减少手动管理资源所带来的繁琐和错误风险，还能深刻理解RAII（Resource Acquisition Is Initialization）资源管理模式的精髓，从而在编程实践中更加高效、安全地管理资源 我们共同见证了std::unique_ptr、std::shared_ptr以及std::weak_ptr等智能指针的神奇之处，从它们的设计理念到实际应用，从基本用法到高级技巧，我们一步步深入，逐渐揭开了智能指针的神秘面纱。相信通过本文的学习，你已经对C++智能指针有了更为全面和深入的理解，也能够在自己的编程实践中灵活运用这一强大工具 但是我还是想说，学习之路永无止境。智能指针只是C++浩瀚知识海洋中的一朵浪花，还有更多精彩的内容等待我们去发掘和探索，不断提升自己的编程能力，在编程的世界里创造属于自己的辉煌  希望本文能够为你提供有益的参考和启示，让我们一起在编程的道路上不断前行！ 谢谢大家支持本篇到这里就结束了，祝大家天天开心！  免责声明：本内容来源于网络，如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！ |
