【C++】智能指针（RAII）详解

Love The Way You Lie 2024-04-22 22:20 83阅读 0赞

![d1003e46d93f46ca9c308a96b3347d99.gif][]

> 我们在上篇文章中（[异常处理详解][Link 1]）提到了 RAII 。那么本篇文章会对此进行详解。重点是智能指针的详解。其中会讲解到 **RAII 思想、auto\_ptr、unique\_ptr、shared\_ptr、weak\_ptr、循环引用问题**。希望本篇文章会对你有所帮助。

> **文章目录**
> 
> 一、为什么需要智能指针
> 
> 二、智能指针的使用及原理
> 
> 2、1 RAII 解释
> 
> 2、2 什么是智能指针
> 
> 2、3 auto\_ptr
> 
> 2、3、1 auto\_ptr 的使用
> 
> 2、3、2 auto\_ptr 的模拟实现
> 
> 2、4 unique\_ptr
> 
> 2、5 shared\_ptr
> 
> 三、循环引用问题及解决
> 
> 3、1 weak\_ptr
> 
> 四、内存泄漏问题
> 
> 4、1 什么是内存泄漏
> 
> 4、2 内存泄漏分类
> 
> 4、3 如何规避内存泄漏
> 
> --------------------
> 
> **?♂️ 作者：@Ggggggtm ?♂️**
> 
> **? 专栏：C++ ?**
> 
> **? 标题：智能指针 ?**
> 
> **❣️ 寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️**

## 一、为什么需要智能指针 ##

> 我们先看如下一段代码：
> 
>     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;
>     }
> 
> 上述一段简短的代码，其实隐含了许多问题。这里给出三个问题：1、如果p1这里new 抛异常会如何？2、如果p2这里new 抛异常会如何？3、如果div调用这里又会抛异常会如何？其实都会造成内存泄露。当然，我们上篇文章也讲到，可以选择异常重新抛出进行解决，但是如果 p2 内存申请失败了呢？有人说可以进行异常检查。确实可以处理。但是这仅仅只有两个动态申请指针。如果类似还有p3、p4、p5……就要进行很复杂的分情况处理。
> 
> 智能指针就可以很轻松的解决上述的情况。下面我们学习一下智能指针。

## 二、智能指针的使用及原理 ##

### 2、1 RAII 解释 ###

> 在了解指针指针之前，我们先学习一下RAII。
> 
> RAII，全称Resource Acquisition Is Initialization（**资源获取即初始化**），是一种在C++中用于管理资源的编程技术。它基于一种简单的原则，即**在对象的构造函数中获得资源**（例如内存、文件句柄、锁等），**并在析构函数中释放这些资源**。**RAII采用的是C++的对象生命周期管理机制，确保在对象离开作用域时资源的正确释放，无论是通过正常流程离开还是通过异常离开**。
> 
> 在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
> 
>  *  不需要显式地释放资源。
>  *  采用这种方式，对象所需的资源在其生命期内始终保持有效。

> 我们通过一段代码来理解一下：
> 
>     // 使用RAII思想设计的SmartPtr类
>     template<class T>
>     class SmartPtr {
>     public:
>     	SmartPtr(T* ptr = nullptr)
>     		: _ptr(ptr)
>     	{}
>     	~SmartPtr()
>     	{
>     		if (_ptr)
>     			delete _ptr;
>     	}
>     private:
>     	T* _ptr;
>     };
>     int div()
>     {
>     	int a, b;
>     	cin >> a >> b;
>     	if (b == 0)
>     		throw invalid_argument("除0错误");
>     	return a / b;
>     }
>     void Func()
>     {
>     	ShardPtr<int> sp1(new int);
>     	ShardPtr<int> sp2(new int);
>     	cout << div() << endl;
>     }
>     int main()
>     {
>     	try {
>     		Func();
>     	}
>     	catch (const exception& e)
>     	{
>     		cout << e.what() << endl;
>     	}
>     	return 0;
>     }
> 
> 上述代码就是把动态申请的资源交给一个类对象处理，我们只需要在该类的析构函数中对该对象进行释放即可。这样做的好处是什么呢？首先，**我们不用自己手动去释放动态申请的资源**。其次，**即使程序出现异常崩溃了，也会将资源释放掉（类对象出了作用域会自动调用析构函数）**。***上述思想就是所谓了资源获取即初始化***。

### 2、2 什么是智能指针 ###

> 传统的指针在使用过程中需要手动分配和释放内存，经常容易出现内存泄漏或者悬挂指针等问题，给程序带来安全隐患。
> 
> 智能指针**是一种特殊类型的指针，它可以自动管理内存的分配和释放**，为程序员提供方便和安全。智能指针**通过在对象生命周期结束时自动释放指向的内存空间，减少了内存泄漏的风险**。
> 
> 我们发现智能指针的概念就是采用了RAII的思想。与上面 SmartPtr 极为相似。但是上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可  
> 以通过->去访问所指空间中的内容。代码如下：
> 
>     template<class T>
>     class SmartPtr {
>     public:
>     	SmartPtr(T* ptr = nullptr)
>     		: _ptr(ptr)
>     	{}
>     	~SmartPtr()
>     	{
>     		if (_ptr)
>     			delete _ptr;
>     	}
>     	T& operator*() { return *_ptr; }
>     	T* operator->() { return _ptr; }
>     private:
>     	T* _ptr;
>     };
>     struct Date
>     {
>     	int _year;
>     	int _month;
>     	int _day;
>     };
>     int main()
>     {
>     	SmartPtr<int> sp1(new int);
>     	*sp1 = 10;
>     	cout << *sp1 << endl;
>     
>     	// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
>     	// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
>     	SmartPtr<Date> sparray(new Date);
>     	sparray->_year = 2018;
>     	sparray->_month = 1;
>     	sparray->_day = 1;
>     	return 0;
>     }

### 2、3 auto\_ptr ###

> 在C++中,auto\_ptr是一个早期的智能指针类，用于管理动态分配的对象。它是C++98标准引入的，但已在C++11中基本上被废弃。我们来看看其使用和为什么要别弃用。

#### 2、3、1 auto\_ptr 的使用 ####

> ![3db04f95dcad4a1383a829d5ded96346.png][] 我们先看如下代码：
> 
>     class A
>     {
>     public:
>     	~A()
>     	{
>     		cout << "~A()" << endl;
>     	}
>     	//private:
>     	int _a1 = 0;
>     	int _a2 = 0;
>     };
>     
>     int main()
>     {
>     	auto_ptr<A> ap1(new A);
>     	ap1->_a1++;
>     	ap1->_a2++;
>     
>     	auto_ptr<A> ap2(ap1);
>     	ap1->_a1++;
>     	ap1->_a2++;
>     	return 0;
>     }
> 
> 运行结果是崩溃了，如下图：
> 
> ![de2ee3564f4440f7bc34daf491e00dbd.png][]
> 
> 这是为什么呢？当将一个auto\_ptr拷贝给另一个auto\_ptr时，将会管理权（资源）转移（这里是指将ap1的资源转移给了ap2）。
> 
> ![0b28026112e849febea24f1809ad96dd.png][]
> 
> 这个看上去好像没有什么问题，但是又好像是一个bug级别的存在。因为一不下心再去使用ap1 时，就会出现内存问题。其实底层实现也是管理权转移的思想。这也是auto\_ptr现在基本上被弃用的原因了。auto\_ptr 的接口含有很多，这里就不再一一解释。
> 
> ![bc971c77314d43868fcfcb663057103a.png][]
> 
> 我们再看一下其底层实现。

#### 2、3、2 auto\_ptr 的模拟实现 ####

> auto\_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份bit::auto\_ptr来了解它的原理。
> 
>     template<class T>
>     	class auto_ptr 
>     	{
>     	public:
>     		auto_ptr(T* ptr = nullptr)
>     			: _ptr(ptr)
>     		{}
>     
>     		auto_ptr(auto_ptr<T>& ap)
>     			:_ptr(ap._ptr)
>     		{
>     			ap._ptr = nullptr;
>     		}
>     
>     		// ap1 = ap2;
>     		auto_ptr<T>& operator=(auto_ptr<T>& ap)
>     		{
>     			if (this != &ap)
>     			{
>     				if (_ptr)
>     				{
>     					delete _ptr;
>     				}
>     
>     				_ptr = ap._ptr;
>     				ap._ptr = nullptr;
>     			}
>     
>     			return *this;
>     		}
>     
>     		~auto_ptr()
>     		{
>     			if (_ptr)
>     			{
>     				delete _ptr;
>     			}
>     		}
>     
>     		T& operator*()
>     		{
>     			return *_ptr;
>     		}
>     
>     		T* operator->()
>     		{
>     			return _ptr;
>     		}
>     
>     	private:
>     		T* _ptr;
>     	};
> 
> 注意，赋值并不只是资源转移。赋值是先将原本对象的资源进行释放，在进行资源转移。同时，在模拟实现时也需要注意是否自己和自己进行赋值。

### 2、4 unique\_ptr ###

> unique\_ptr 针对auto\_ptr 的不足进行了调整，但是调整的有点暴力。在unique\_ptr 中，直接将拷贝构造和拷贝赋值直接禁用了。
> 
> ![01823b2faba347ecb96a3688306a6b44.png][]![67d633aa14c543db8c2d56cf856274a6.png][]
> 
> 其用法与auto\_ptr 基本相似，只不过是尽禁掉了拷贝构造和拷贝赋值。我们再来看一下其底层的简单模拟实现。代码如下：
> 
>     template<class T>
>     	class unique_ptr
>     	{
>     	private:
>     		// 防拷贝 C++98
>     		// 只声明不实现 
>     		//unique_ptr(unique_ptr<T>& ap);
>     		//unique_ptr<T>& operator=(unique_ptr<T>& ap);
>     	public:
>     		unique_ptr(T* ptr = nullptr)
>     			: _ptr(ptr)
>     		{}
>     
>     		// 防拷贝 C++11
>     		unique_ptr(unique_ptr<T>& ap) = delete;
>     		unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;
>     
>     		~unique_ptr()
>     		{
>     			if (_ptr)
>     			{
>     				cout << "Delete:" << _ptr << endl;
>     				delete _ptr;
>     			}
>     		}
>     
>     		T& operator*()
>     		{
>     			return *_ptr;
>     		}
>     
>     		T* operator->()
>     		{
>     			return _ptr;
>     		}
>     
>     	private:
>     		T* _ptr;
>     	};
> 
> unique\_ptr与auto\_ptr极为相似，就不再过多解释unique\_ptr。我们重点是在shared\_ptr。

### 2、5 shared\_ptr ###

> shared\_ptr 针对之前的智能指针的问题进行了修改调整。不仅仅支持拷贝，而且也更加安全。其使用我们也不再过多详解，主要看一下其底层实现。
> 
> shared\_ptr的原理：是通过引用计数的方式来实现多个shared\_ptr对象之间共享资源。
> 
> 1.  shared\_ptr在其内部，给**每个资源都维护了着一份计数（引用计数）**，**用来记录该份资源被几个对象共享**。
> 2.  在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
> 3.  如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
> 4.  如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

> 那我们怎么来维护这个计数呢？首先，普通的 int 成员是不可以的。因为我们想要的时一个类对象只有一个计数。如果是普通的 int 成员，实例化每个对象都会都一个计数。
> 
> 用static 成员可不可以呢？也是不行的！我们看如下代码：
> 
>     shared_ptr<A> sp1(new A);
>     shared_ptr<A> sp2(sp1);
>     shared_ptr<A> sp3(sp1);
>     
>     shared_ptr<int> sp4(new int);
> 
> 如果是 static 成员，那么不同类型的对象也是共享一个计数。显然这样是不正确的。
> 
> **采用一个指针可不可以呢？答案是可以的。我们采用指针时，只有在构造时，才进行申请新的指针。当采用拷贝或者赋值时，我们选择将指针进行资源转移，而不是申请新指针**。这样就可以很好的控制一个类对象只有一个计数了。下面我们结合模拟实现的代码理解一下：
> 
>     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();
>     		}
>     
>     		// sp1(sp2)
>     		shared_ptr(const shared_ptr<T>& sp)
>     			: _ptr(sp._ptr)
>     			, _pCount(sp._pCount)
>     		{
>     			(*_pCount)++;
>     		}
>     
>     		// sp1 = sp5
>     		// sp1 = sp1
>     		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
>     		{
>     			//if (this == &sp)
>     			if (_ptr == sp._ptr)
>     			{
>     				return *this;
>     			}
>     
>     			// 减减被赋值对象的计数，如果是最后一个对象，要释放资源
>     			/*if (--(*_pCount) == 0)
>     			{
>     				delete _ptr;
>     				delete _pCount;
>     			}*/
>     			Release();
>     
>     			// 共管新资源，++计数
>     			_ptr = sp._ptr;
>     			_pCount = sp._pCount;
>     
>     			(*_pCount)++;
>     
>     			return *this;
>     		}
>     
>     		T& operator*()
>     		{
>     			return *_ptr;
>     		}
>     
>     		T* operator->()
>     		{
>     			return _ptr;
>     		}
>     
>     	private:
>     		T* _ptr;
>     
>     		// 引用计数
>     		int* _pCount;
>     	};
>     }

## 三、循环引用问题及解决 ##

> 循环引用是指**两个或多个对象之间相互引用**，**形成一个闭环的情况**。这种情况下，由于每个对象都持有其他对象的引用计数，**导致共享指针无法正确地释放内存**。下面我们来看一个实际的例子：
> 
>     struct Node
>     {
>     	int _val;
>     	std::shared_ptr<Node> _next;
>     	std::shared_ptr<Node> _prev;
>     
>     	~Node()
>     	{
>     		cout << "~Node" << endl;
>     	}
>     };
>     
>     void test_shared_ptr2()
>     {
>     	std::shared_ptr<Node> n1(new Node);
>     	std::shared_ptr<Node> n2(new Node);
>     
>     	n1->_next = n2;
>     	n2->_prev = n1;
>     }
> 
> 我们可以简单的理解为：双向链表中存储的是智能指针。这时候就引发了循环引用的问题。具体如下图：
> 
> ![42cf6bf84c0246359583d95227374c13.png][]
> 
> 这个时候可以采用weak\_ptr 来进行解决。

### 3、1 weak\_ptr ###

> weak\_ptr是与shared\_ptr配套使用的弱引用指针。它可以解决循环引用问题，因为它不会增加内存的引用计数。我们先看一下代码：
> 
>     struct Node
>     {
>     	int _val;
>     	/*std::shared_ptr<Node> _next;
>     	std::shared_ptr<Node> _prev;*/
>     
>     	std::weak_ptr<Node> _next;
>     	std::weak_ptr<Node> _prev;
>     
>     	~Node()
>     	{
>     		cout << "~Node" << endl;
>     	}
>     };
> 
> \_next和\_prev是weak\_ptr时，**他不参与资源释放管理，可以访问和修改到资源，但是不增加计数**，不存在循环引用的问题了。

## 四、内存泄漏问题 ##

### 4、1 什么是内存泄漏 ###

> 内存泄漏是指在计算机程序中，**通过动态分配内存空间后，无法再次释放这些空间的情况**。当程序运行时，如果不再使用某段动态分配的内存空间，但没有显式地将其释放，就会导致内存泄漏的问题。
> 
> 内存泄漏可能会导致系统性能下降甚至崩溃。随着时间的推移，内存泄漏会使可用内存越来越少，最终导致程序运行失败或系统崩溃。
> 
> 在C++中，内存泄漏通常出现在以下情况下：
> 
> 1.  动态分配内存后未释放：当使用关键字`new`或者相关的内存分配函数（例如`malloc`）在堆上分配了内存空间后，如果没有调用对应的释放函数（例如`delete`或者`free`），就会发生内存泄漏。这种情况经常出现在忘记释放内存、程序异常退出等情况下。
> 2.  在循环中动态分配内存未释放：当在循环中重复动态分配内存空间而未及时释放，在每次循环迭代时都会导致一次内存泄漏。
>     
>         for (int i = 0; i < 10; i++) {
>             int* ptr = new int; // 动态分配了一个int型的内存空间
>             // 未在每次循环结束时释放ptr指向的内存空间，导致每次循环都有内存泄漏
>         }
> 3.  没有正确管理对象的生命周期：当对象在不再使用时没有及时销毁或释放资源，也可能导致内存泄漏。
>     
>         class MyClass {
>         public:
>             MyClass() {
>                 buffer = new int[1000]; // 在构造函数中动态分配了一个int数组
>             }
>             ~MyClass() {
>                 // 在析构函数中应该释放buffer指向的内存空间，但这里没有进行释放
>             }
>         private:
>             int* buffer;
>         };
>         
>         void foo() {
>             MyClass obj;
>             // 在此处，obj的析构函数没有被调用，导致buffer指向的内存泄漏
>         }
> 4.  循环引用：如果两个或多个对象互相引用，并且没有其他对象引用它们，那么这些对象将无法很好的释放资源，导致内存泄漏。
> 5.  异常跳转，可能会直接跳转过了释放资源的语句。也会导致内存泄漏。

### 4、2 内存泄漏分类 ###

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

### 4、3 如何规避内存泄漏 ###

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

[d1003e46d93f46ca9c308a96b3347d99.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/973a782a5c8e470fa39a0edd2e692409.gif
[Link 1]: https://blog.csdn.net/weixin_67596609/article/details/132640403?spm=1001.2014.3001.5501
[3db04f95dcad4a1383a829d5ded96346.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/54a54cbc0f1f477d882b7522d82cd292.png
[de2ee3564f4440f7bc34daf491e00dbd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/bc0dc9f171294858b091bf7fc0bc5836.png
[0b28026112e849febea24f1809ad96dd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/4bbea13be9724df29ee214aff7267ff5.png
[bc971c77314d43868fcfcb663057103a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d4bafb87dad44732bb87c48eb7300f5c.png
[01823b2faba347ecb96a3688306a6b44.png]: https://img-blog.csdnimg.cn/01823b2faba347ecb96a3688306a6b44.png
[67d633aa14c543db8c2d56cf856274a6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/d19c736998f6473e801a8d8a028c85be.png
[42cf6bf84c0246359583d95227374c13.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/22/93b321f355d7447baba22649d207021f.png