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

C++之C++11新特性（三）--- 智能指针

news 来源：原创 2025/5/13 10:55:43

一、智能指针

1.1 为什么需要智能指针

1.2 内存泄漏

1.2.1 内存泄漏的基本概念

1.2.2 内存泄漏的分类

1.2.3 如何避免内存泄漏

1.3 智能指针的使用及其原理

1.3.1 RAII

1.3.2 智能指针的基本原理

1.3.3 auto_ptr

1.3.4 unique_ptr

1.3.5 shared_ptr

1.3.6 shared_ptr中的循环引用问题

1.3.7 定制删除器

一、智能指针

1.1 为什么需要智能指针

首先咱们来看一段代码：

int div()
{int a, b;cin >> a >> b;if (b == 0)throw invalid_argument("除0错误");return a / b;
}
void Func()
{
// 1、如果p1这里new 抛异常会如何？
// 2、如果p2这里new 抛异常会如何？
// 3、如果div调用这里又会抛异常会如何？int* p1 = new int;int* p2 = new int;cout << div() << endl;delete p1;delete p2;
}
int main()
{try{Func();}catch (exception& e){cout << e.what() << endl;}return 0;
}

如果我们在div中b为0的话，我们的程序将会抛出异常，使得在Func函数cout之后的语句都不会执行，那就会导致p1,p2所指向的资源没有被及时的释放，就会导致资源泄露的问题，所以很明显，这里我们需要采取一些其他方法来管理我们的资源，在讲其他方法之前，先让我们来看看内存泄漏。

1.2 内存泄漏

1.2.1 内存泄漏的基本概念

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

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

1.2.2 内存泄漏的分类

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

1.2.3 如何避免内存泄漏

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

1.3 智能指针的使用及其原理

1.3.1 RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

不需要显式地释放资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效。

1.3.2 智能指针的基本原理

现在让我们根据RAII的基本思想来写一个简单的SmartPtr:

template <class T>
class SmartPtr {SmartPtr(T* ptr):_ptr(ptr){}~SmartPtr(){if (_ptr != nullptr) delete _ptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}
private:T* _ptr;
};

这只是我简易实现的一个智能指针，库里面当然也有现成的智能指针，接下来就来让我们看看吧

1.3.3 auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto_ptr来了解它的原理.我们可以来看看其原理。

template <class T>
class my_auto_ptr {my_auto_ptr(T* ptr) :_ptr(ptr){}~my_auto_ptr(){if (_ptr != nullptr) delete _ptr;}my_auto_ptr(my_auto_ptr<T>& sp):_ptr(sp._ptr){sp._ptr = nullptr;}T* operator=(my_auto_ptr<T>& ptr){//检测是否给自己赋值if (this != &ptr){if (_ptr) delete _ptr;_ptr = ptr._ptr;ptr._ptr = nullptr;}return *this;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}private:T* _ptr;
};

但是呢，auto_ptr并不是一个优秀的设计，不建议使用

1.3.4 unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝，

下面简化模拟实现了一份UniquePtr来了解它的原理

template<class T>
class my_unique_ptr {my_unique_ptr(T* ptr) :_ptr(ptr){}~my_unique_ptr(){if (_ptr != nullptr) delete _ptr;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}my_unique_ptr(const my_unique_ptr<T>& ptr) = delete;my_unique_ptr<T>& operator=(const my_unique_ptr<T>& ptr) = delete;private:T* _ptr;
};

1.3.5 shared_ptr

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。例如：老师晚上在放学之前都会通知，让最后走的学生记得把门锁下。

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

接下来同样先尝试模拟实现一下吧:

template<class T>
class my_shared_ptr {my_shared_ptr(T* ptr = nullptr) :_ptr(ptr),_pcount(new int(1)){}~my_shared_ptr(){Release();}void Release(){if (--(*_pcount) == 0){delete _ptr;delete _pcount;}}void AddCount(){(*_pcount)++;}T& operator*(){return *_ptr;}T* operator->(){return _ptr;}my_shared_ptr(const my_shared_ptr<T>& ptr){_ptr = ptr._ptr;_pcount = ptr._pcount;AddCount();}my_shared_ptr<T>& operator=(const my_shared_ptr<T>& ptr){if (_ptr != ptr._ptr){Release();_ptr = ptr._ptr;_pcount = ptr._pcount;AddCount();}return *this;}private:T* _ptr;int* _pcount;
};

这个版本的智能指针就是目前使用最为常见和广泛的了。

1.3.6 shared_ptr中的循环引用问题

这里用一张图来给大家说明一下这个问题，
先引入一段代码

struct ListNode
{int _data;shared_ptr<ListNode> _prev;shared_ptr<ListNode> _next;~ListNode(){ cout << "~ListNode()" << endl; }
}int main()
{shared_ptr<ListNode> node1(new ListNode);shared_ptr<ListNode> node2(new ListNode);cout << node1.use_count() << endl;cout << node2.use_count() << endl;node1->_next = node2;node2->_prev = node1;cout << node1.use_count() << endl;cout << node2.use_count() << endl;return 0;
}

这里需要提前说明的是，node1与node2都不会正常释放的，下面来说说为什么。

node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete
node1的_next指向node2，node2的_prev指向node1，引用计数变成2
node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点
也就是说_next析构了，node2就释放了
也就是说_prev析构了，node1就释放了
但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放

这就是循环引用问题，那么要怎么解决循环引用问题呢，在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了。

struct ListNode
{int _data;weak_ptr<ListNode> _prev;weak_ptr<ListNode> _next;~ListNode(){ cout << "~ListNode()" << endl; }
}

当然以上这种循环引用的情况，咱们能避免就避免，免得恶心自己。

1.3.7 定制删除器

当我们遇到一些场景时，系统提供的默认删除器是解决不了问题的，例如：

shared_ptr<int> sp1(new int[10]);
shared_ptr<FILE> sp2(fopen("test.txt","r"));

像这样的场景，使用默认的删除器是肯定会报错的，但是在构造函数的地方可以传入一个定制
删除器,也就是一个函数对象，当我们有传入删除器时，系统就会使用我们所提供的删除器来释放我们的资源，例如，上述代码我们可以这样改写：

shared_ptr<int> sp1(new int[10]，[](int* arr){ delete[] arr; });
shared_ptr<FILE> sp2(fopen("test.txt","r"),[](FILE* ptr){ fclose(ptr); });

当我们有了定制删除器后，我们的shared_ptr就可以帮助我们处理更多的场景。

一、智能指针

1.1 为什么需要智能指针

1.2 内存泄漏

1.2.1 内存泄漏的基本概念

1.2.2 内存泄漏的分类

1.2.3 如何避免内存泄漏

1.3 智能指针的使用及其原理

1.3.1 RAII

1.3.2 智能指针的基本原理

1.3.3 auto_ptr

1.3.4 unique_ptr

1.3.5 shared_ptr

1.3.6 shared_ptr中的循环引用问题

1.3.7 定制删除器

相关文章：