【C++高阶】深入理解C++智能指针：掌握RAII与内存安全的利器

📝个人主页🌹：Eternity._
⏩收录专栏⏪：C++ “ 登神长阶 ”
🤡往期回顾🤡：C++异常处理机制
🌹🌹期待您的关注 🌹🌹

前言：在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++)：

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

当我们正常输入时：程序正常

当我们程序异常终止时：申请的空间并不会被释放

这样就会造成内存泄漏，因此为了能够限制内存泄漏，就有了智能指针

📚2. 智能指针的使用及原理

智能指针（Smart Pointers）是现代C++编程中非常重要的一种内存管理技术，旨在解决原始指针使用过程中的内存泄漏、野指针等问题。智能指针是模板类，能够像普通指针一样被操作，但它能在适当的时候自动释放所管理的对象，从而保证资源的正确释放

⛰️RAII

RAII是一种在C++（以及C++风格的其他编程语言中）常用的资源管理技术。

它的基本思想是：资源的获取在对象的构造时完成，而资源的释放（Release）则在对象的生命周期结束时自动执行，通常是在对象的析构函数中完成。我们实际上把管理一份资源的责任托管给了一个对象，这种方式有助于管理如动态分配的内存、文件句柄、网络连接、互斥锁等需要显式释放的资源

RAII的好处

• 自动资源管理： RAII通过对象的生命周期来管理资源，一旦对象被销毁，其所管理的资源也会被自动释放，无需手动调用释放函数
• 异常安全： 由于资源的释放是在对象的析构函数中进行的，而析构函数会在对象生命周期结束时自动调用，即使发生异常也是如此，因此可以保证资源的正确释放，避免了资源泄露
• 简化代码： 使用RAII可以使得资源管理相关的代码更加简洁，减少了因忘记释放资源而导致的错误

使用RAII思想设计的SmartPtr类：

template<class T>
class SmartPtr {
public:SmartPtr(T* ptr = nullptr): _ptr(ptr){}~SmartPtr(){cout << "delete -> " << _ptr << endl;delete _ptr;}
private:T* _ptr;
};

🌄智能指针的原理

但是刚刚的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用

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 = 10cout<<*sp1<<endl;return 0;
}

智能指针的原理：

• RAII特性
• 重载operator*和opertaor->，具有像指针一样的行为

🌞std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针

std::auto_ptr文档

auto_ptr的实现原理：管理权转移的思想，我们来简单模拟实现一下它，来了解它的原理

auto_ptr模拟实现 (C++)：

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

但是由于auto_ptr存在较严重的问题，很多公司明确要求不能使用

void Test_auto_ptr()
{pxt::auto_ptr<int> ap1(new int);pxt::auto_ptr<int> ap2 = ap1;// 管理权转移，导致ap1对象悬空/*(*ap1)++;(*ap2)++;*/
}

🌙std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

std::unique_ptr文档文档

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理

C++11出来之前，
boost搞出了更好用的scoped_ptr/shared_ptr/weak_ptr
之后C++11借鉴了boost库中智能指针，
C++11搞出unique_ptr/shared_ptr/weak_ptr

unique_ptr模拟实现 (C++)：

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

void Test_unique_ptr()
{pxt::unique_ptr<int> up1(new int);//pxt::unique_ptr<int> up2(up1);
}

⭐std::shared_ptr与std::weak_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

std::shared_ptr文档文档

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源

• shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享
• 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一
• 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源
• 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了

shared_ptr模拟实现 (C++)：

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

强如shared_ptr也会存在一定的问题需要我们解决，我们在使用shared_ptr的时候一定要注意，不能循环引用

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

解决方案：
在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数

weak_ptr模拟实现 (C++)：

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

循环引用解决方案：

struct ListNode
{int val;pxt::weak_ptr<ListNode> prev;pxt::weak_ptr<ListNode> next;~ListNode(){cout << "~ListNode()" << endl;}
};

删除器

shared_ptr设计了一个删除器来解决一些不是new出来的对象的智能指针管理

仿函数的删除器 (C++)：

template<class T>
struct DelArray
{void operator()(T* ptr){delete[] ptr;}
};

在增加删除器后，shared_ptr的参数变多了，因此我们还要修改一下shared_ptr的模拟实现

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; }; // 提供一个缺省参数，确保在没有提供删除器的情况下能正常使用
};

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]);

📜3. 内存泄漏

内存泄漏：指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费

🍁内存泄漏的危害

内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死

内存泄漏的原因：

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

🍂内存泄漏的分类与检测 (了解)

C/C++程序中一般有两种方面的内存泄漏：

• 堆内存泄漏(Heap leak)
  堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一
  块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分
  内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak
• 系统资源泄漏
  指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放
  掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定

检测内存泄漏：
在linux下内存泄漏检测：linux下几款内存泄漏检测工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄漏工具比较

🌸如何避免内存泄漏

• 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放
  ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
• 采用RAII思想或者智能指针来管理资源
• 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项
• 出问题了使用内存泄漏工具检测
  ps：不过很多工具都不够靠谱，或者收费昂贵

内存泄漏常见解决方案分为两种：

• 事前预防型。如智能指针等
• 事后查错型。如泄漏检测工具

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

• C++ 98 中产生了第一个智能指针auto_ptr
• C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr
• C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版
• C++ 11，引入了unique_ptr和shared_ptr和weak_ptr

在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++浩瀚知识海洋中的一朵浪花，还有更多精彩的内容等待我们去发掘和探索，不断提升自己的编程能力，在编程的世界里创造属于自己的辉煌

希望本文能够为你提供有益的参考和启示，让我们一起在编程的道路上不断前行！
谢谢大家支持本篇到这里就结束了，祝大家天天开心！