C++11标准下的智能指针

布满荆棘的人生 2022-10-17 13:56 9阅读 0赞

# 智能指针 #

为什么要提出智能指针的概念？能够解决什么问题？优点是什么？

智能指针的提出主要是解决内存泄漏的问题

那么何为内存泄漏呢？

*  ### 内存泄漏 ###

**内存泄漏并不是物理内存空间的丢失，而是应用程序分配某段内存空间后，由于疏忽或设计错误导致程序未能释放已经不再使用的内存空间，失去对这部分空间的控制，从而造成内存泄漏**

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

*  ### 内存泄漏的分类 ###
 *  **堆内存泄漏（heap leak）**

**堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak**

*  **系统资源泄漏**

**指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。**

*  ### **内存泄漏解决方法** ###

1.  **作为一位合格的程序猿或者攻城狮，工程前期就需要养成良好的代码书写规范，以及工程设计规范，凡是涉及到手动内存开辟，一定要记得及时释放，切莫置之不理。但这毕竟是一种理想状态，人为开辟内存或释放肯定会存在人为疏忽，对此，需要借助一种智能指针自动完成。**
2.  **借助RALL思想完成对智能指针的设计**
3.  **借助一下内存检测工具检查程序段是否存在内存泄漏**

### **本文重点介绍通过智能指针如何解决内存泄漏** ###

**智能指针的设计主要依靠RALL思想，所谓RALL思想就是通过对象的生命周期来控制资源回收**

**简言之，把一份资源管理的责任托管给了对象，不再需要显示释放资源而且采用这种方式，对象所需的资源在其生命期内始终保持有效。**

**在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。**

*  ### **常见的智能指针** ###
 *  **智能指针smart\_ptr**

**代码如下：**

#include<iostream>
    using namespace std;
    
    // 使用RAII思想设计的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;
    };
    
    void test()
    {
    	SmartPtr<int> p(new int);
    	//要求必须立即初始化,以下并非立即初始化 写法错误：
    	/*int* ptr = new int;
    	SmartPtr<int> p(ptr);*/
    	*p = 10;
    	cout << *p << endl;
    
    	SmartPtr<Date> sparray(new Date);
    	sparray->_year = 2021;
    	sparray->_month = 9;
    	sparray->_day = 21;
    	cout << (*sparray)._year << (*sparray)._month << (*sparray)._day << endl;
    	return;//return后对象生命周期结束，调用析构函数自动释放空间
    	cout << "test..." << endl;
    }
    
    int main()
    {
    	test();
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1][]

*  **Auto\_ptr(一般不推荐使用)**

实现管理权转移，当发生拷贝或赋值过程，前面的对象就被置空，将原有对象资源转移到当前对象，这虽然解决了一块内存空间多个对象调用导致崩溃的问题，但会使得原有对象失效，后续无法再调用

**代码如下：**

#include<iostream>
    using namespace std;
    
    template<class T>
    class AutoPtr
    {
    public:
    	AutoPtr(T* ptr = NULL)
    		: _ptr(ptr)
    	{}
    	~AutoPtr()
    	{
    		if (_ptr)
    			delete _ptr;
    	}
    	// 一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
    	// 这样就解决了一块空间被多个对象使用而造成程序奔溃问题
    	AutoPtr(AutoPtr<T>& ap)
    		: _ptr(ap._ptr)
    	{
    		ap._ptr = NULL;
    	}
    	AutoPtr<T>& operator=(AutoPtr<T>& ap)
    	{
    		// 检测是否为自己给自己赋值
    		if (this != &ap)
    		{
    			// 释放当前对象中资源
    			if (_ptr)
    				delete _ptr;
    			// 转移ap中资源到当前对象中
    			_ptr = ap._ptr;
    			ap._ptr = NULL;
    		}
    		return *this;
    	}
    	T& operator*() { return *_ptr; }
    	T* operator->() { return _ptr; }
    private:
    	T* _ptr;
    };
    
    struct Date
    {
    	int _year;
    	int _month;
    	int _day;
    };
    
    int main()
    {
    	AutoPtr<Date> ap(new Date);
    	// 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
    	// 通过ap对象访问资源时就会出现问题。
    	AutoPtr<Date> copy(ap);
    	ap->_year = 2020;
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 3][]

*  **unique\_ptr(基于auto\_ptr存在问题而提出)**

**基本思想就是直接屏蔽拷贝和赋值**

#include<iostream>
    using namespace std;
    template<class T>
    class Unique_Ptr {
    public:
    	Unique_Ptr(T* ptr = nullptr)
    		: _ptr(ptr)
    	{}
    
    	~Unique_Ptr()
    	{
    		if (_ptr)
    			delete _ptr;
    	}
    	//防止拷贝delete
    	Unique_Ptr(const Unique_Ptr<T>& ptr) = delete;
    	Unique_Ptr<T>& operator=(const Unique_Ptr<T>& ptr) = delete;
    
    	T& operator*() { return *_ptr; }
    	T* operator->() { return _ptr; }
    private:
    	T* _ptr;
    };

*  **shared\_ptr**

**shared\_ptr的原理：是通过引用计数的方式来实现多个shared\_ptr对象之间共享资源。  
1. shared\_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。  
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。  
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；  
4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。**

**代码如下：**

#include<iostream>
    using namespace std;
    
    
    template<class T>
    
    class sharedptr
    {
    public:
    	sharedptr(T* ptr)
    		:_ptr(ptr)
    		,_pRefCount(new int(1))
    	{}
    
    	sharedptr(const sharedptr<T>& s)
    		:_ptr(s._ptr)
    		, _pRefCount(s._pRefCount)
    	{
    		(*_pRefCount)++;
    	}
    
    	sharedptr<T>& operator=(const sharedptr<T>& sp)
    	{
    		if (this != &sp)
    		{
    			// 释放管理的旧资源
    			if (--(*_pRefCount) == 0)   //注意：此处计数器指针与下面的计数器指针并非指向同一个  一个指向原有资源计数，另一个指向新资源计数
    			{                           //赋值过程中，被赋值的对象切断原有资源指向，且原有资源计数-1，开始指向新资源，新资源计数+1
    				delete _ptr;
    				delete _pRefCount;
    			}
    			// 共享管理新对象的资源，并增加引用计数
    			_ptr = sp._ptr;
    			_pRefCount = sp._pRefCount;
    			
    			(*_pRefCount)++;
    		}
    		return *this;
    	}
    
    	~sharedptr()
    	{
    		if (--(*_pRefCount) == 0)
    		{
    			delete _ptr;
    			delete _pRefCount;
    		}
    	}
    
    	int UseCount() { return *_pRefCount; }
    
    	T& operator*() { return *_ptr; }
    	T* operator->() { return _ptr; }
    
    private:
    	int* _pRefCount; // 引用计数,
    	T* _ptr; // 指向管理资源的指针
    };
    
    int main()
    {
    	sharedptr<int> sp1(new int(10));
    	sharedptr<int> sp2(sp1);
    	*sp2 = 20;
    	cout << sp1.UseCount() << endl;
    	cout << sp2.UseCount() << endl;
    	sharedptr<int> sp3(new int(10));
    	sp2 = sp3;
    	cout << sp1.UseCount() << endl;
    	cout << sp2.UseCount() << endl;
    	cout << sp3.UseCount() << endl;
    	sp1 = sp3;
    	cout << sp1.UseCount() << endl;
    	cout << sp2.UseCount() << endl;
    	cout << sp3.UseCount() << endl;
    	return 0;
    }

注意：

1.  计数器定义为指针，目的是保证不同对象析构后，计数器值要同步更新
2.  在赋值运算符重写过程中 此处计数器指针与下面的计数器指针并非指向同一个 一个指向原有资源计数，另一个指向新资源计数。赋值过程中，被赋值的对象切断原有资源指向，且原有资源计数-1，开始指向新资源，新资源计数+1

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 4][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 5][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 6][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 7][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 8][]

*   **shared\_ptr循环引用**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 9][]

**代码如下：**

#include<iostream>
    using namespace std;
    
    
    template<class T>
    
    class sharedptr
    {
    public:
    	sharedptr(T* ptr)
    		:_ptr(ptr)
    		,_pRefCount(new int(1))
    	{}
    
    	sharedptr(const sharedptr<T>& s)
    		:_ptr(s._ptr)
    		, _pRefCount(s._pRefCount)
    	{
    		(*_pRefCount)++;
    	}
    
    	sharedptr<T>& operator=(const sharedptr<T>& sp)
    	{
    		if (this != &sp)
    		{
    			// 释放管理的旧资源
    			if (--(*_pRefCount) == 0)   //注意：此处计数器指针与下面的计数器指针并非指向同一个  一个指向原有资源计数，另一个指向新资源计数
    			{                           //赋值过程中，被赋值的对象切断原有资源指向，且原有资源计数-1，开始指向新资源，新资源计数+1
    				delete _ptr;
    				delete _pRefCount;
    			}
    			// 共享管理新对象的资源，并增加引用计数
    			_ptr = sp._ptr;
    			_pRefCount = sp._pRefCount;
    			
    			(*_pRefCount)++;
    		}
    		return *this;
    	}
    
    	~sharedptr()
    	{
    		if (--(*_pRefCount) == 0)
    		{
    			delete _ptr;
    			delete _pRefCount;
    		}
    	}
    
    	int UseCount() { return *_pRefCount; }
    
    	T& operator*() { return *_ptr; }
    	T* operator->() { return _ptr; }
    
    private:
    	int* _pRefCount; // 引用计数,
    	T* _ptr; // 指向管理资源的指针
    };
    
    struct ListNode
    {
    	int _data;
    	sharedptr<ListNode> _prev;
    	sharedptr<ListNode> _next;
    	ListNode()
    		:_prev(nullptr)
    		,_next(nullptr)
    		,_data(10)
    	{}
    	~ListNode() { cout << "~ListNode()" << endl; }
    };
    
    int main()
    {
    	sharedptr<ListNode> node1(new ListNode);
    	sharedptr<ListNode> node2(new ListNode);
    	cout << node1.UseCount() << endl;
    	cout << node2.UseCount() << endl;
    	node1->_next = node2;
    	node2->_prev = node1;
    	cout << node1.UseCount() << endl;
    	cout << node2.UseCount() << endl;
    	return 0;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 10][]

**node1->\_next = node2;和node2->\_prev = node1;时 导致引用计数增加为2**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 11][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 12][]

**出现问题：**

**node1和node2析构，引用计数减到1，但是\_next还指向下一个节点。但是\_prev还指向上一个节点。也就是说\_next析构了，node2就释放了。 \_prev析构了，node1就释放了。  
但是\_next属于node的成员，node1释放了，\_next才会析构，而node1由\_prev管理，\_prev属于node2成员，所以这就叫循环引用，谁都不会释放资源**

*  **采用weak\_ptr解决上述问题**

**解决方案：在引用计数的场景下，把节点中的\_prev和\_next改成weak\_ptr就可以了  
原理就是，node1->\_next = node2;和node2->\_prev = node1;时weak\_ptr的\_next和\_prev不会增加node1和node2的引用计数。**

struct ListNode
    {
    	int _data;
    	weak_ptr<ListNode> _prev;
    	weak_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;
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 13][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 14][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70]: /images/20221014/12e589c99e4847fc868701fe4ea60bfe.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 1]: /images/20221014/fd89633cee184a97aa108b8446d3c369.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 2]: /images/20221014/0e49a679cbaf438e82639951ca7daa8c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 3]: /images/20221014/ac7328f6e5404990860add6d73a122bb.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 4]: /images/20221014/3bcb9f80996c45598858491f676c4507.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 5]: /images/20221014/6cc4a4552dd44e7db637f261ea9d8068.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 6]: /images/20221014/a6d9e380d77841d7bca22800716b999e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 7]: /images/20221014/5e89ca09667e49f1a64a2ee3e4c7490f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 8]: /images/20221014/35bb809cf3b94a8eb564be8d796c3df5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 9]: /images/20221014/57e08a877d9e4d208464d8d320d4e64f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 10]: /images/20221014/c90a072b041241378c5c8f16e2ea4cbc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 11]: /images/20221014/b3d1f6f921454cbba001bd312adf0ade.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 12]: /images/20221014/94f672cf502944e08bce13e42430f83f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 13]: /images/20221014/49c9cd0758564a64a6d2753043b2ef18.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2MTMxNjEx_size_16_color_FFFFFF_t_70 14]: /images/20221014/882773fd33a841b4a840a65b4b6b1169.png