C++智能指针——auto_ptr、unique_ptr和shared_ptr详解

今天药忘吃喽~ 2022-09-03 07:26 216阅读 0赞

# 一、为什么使用智能指针？ #

使用智能指针，通常是因为以下两个场景，用一段代码模拟演示：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]  
**问题分析：**

1.  new/malloc申请出来的空间忘记手动释放delete/free，造成指针悬空问题，从而引发内存泄漏
2.  异常安全问题。在malloc/new和free/delete之间抛出异常造成内存泄漏问题。

显然，当面临上述两个场景时我们就需要借助智能指针帮助我们管理内存的申请和释放了

# 二、内存泄漏 #

## 1.1 什么是内存泄漏 ##

对于C/C++程序员来说，内存泄漏往往是加班或调试程序的罪魁祸首。

1.  什么是内存泄漏呢？

*  内存泄漏是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。简单来说，就是**一块内存我们已经失去了对该段内存的控制。**
 *  内存泄漏不是指物理结构上的消失。

## 1.2 内存泄漏的危害？ ##

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

# 三、智能指针的使用与原理 #

## 3.1 RAII ##

RAII(Resource Acquisition Is Initialization)是一种**利用对象生命周期来控制程序资源**的简单技术。

**在对象构造时获取资源**，接着控制对资源的访问使之**在对象的生命周期内始终有效**，最后在对**象析构的时候释放资源**。这种方式的两大好处：  
**1. 不需要显示释放资源  
2. 对象所需的资源在其生命周期内始终保持有效**

## 3.2 C++98——std::auto\_ptr ##

C++98在memory头文件中提供了auto\_ptr智能指针

### <1>auto\_ptr使用及问题 ###

下面看一下auto\_ptr的使用及问题  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]

### <2>auto\_ptr模拟实现 ###

class Date {
        
    public:
    	Date() 
    	{
         cout << "Date()" << endl; }
    	~Date() {
         cout << "~Date()" << endl; }
    	int year;
    	int month;
    	int day;
    };
    
    //1.auto_ptr
    template<class T>
    class Auto_ptr {
        
    public:
    	//构造
    	Auto_ptr(T* ptr = nullptr) 
    		:_ptr(ptr)
    	{
        }
    
    	//析构
    	~Auto_ptr()
    	{
        
    		if (_ptr)
    			delete _ptr;
    	}
    
    	//拷贝构造,对象ap资源的转移,同时将对象ap资源中的指针清空，即断开资源的链接关系
    	//这种方式解决了一个空间被多个对象使用从而造成程序崩溃问题
    	Auto_ptr(Auto_ptr<T>& ap)
    		:_ptr(ap._ptr)
    	{
        
    		ap._ptr = nullptr;
    	}
    
    	//赋值=
    	Auto_ptr<T>& operator=(Auto_ptr<T>& ap)
    	{
        
    		//检测是否自己给自己赋值
    		if (&ap != this)
    		{
        
    			//释放当前对象资源
    			if (_ptr)
    				delete _ptr;
    			//对象ap资源转移
    			_ptr = ap._ptr;
    			ap._ptr = nullptr;
    		}
    
    		return *this;
    	}
    
    	//重载*，->
    	T& operator*(){
         return *_ptr;}
    	T* operator->() {
         return _ptr; }
    
    private:
    	T* _ptr;
    };
    
    void TestAuto_ptr()
    {
        
    	auto_ptr使用及问题
    	//Date* d1 = new Date();
    	1.同一个指针初始化两个智能指针，析构释放两次指针，出现问题
    	//auto_ptr<Date> ap1(d1);
    	//auto_ptr<Date> ap2(d1);
    	立即初始化
    	//auto_ptr<Date> ap3(new Date);
    
    	2.拷贝或赋值导致资源管理权的转移，再次解引用造成指针悬空
    	//uto_ptr<Date> copy1(ap3);
    	//ap3->year = 2021;	//ap指针悬空无法访问
    
    	//模拟实现
    	Auto_ptr<Date> ap4(new Date);
    	Auto_ptr<Date> copy2(ap4);
    	//ap对象拷贝给copy后，ap对象中的指针赋空，造成指针悬空
    	ap4->month = 8;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]  
总结：  
**auto\_ptr只是将对象中资源的管理权限进行转移，并将对象中的指针置空，因此不建议使用！**

## 3.2 std::unique\_ptr ##

### <1>unique\_ptr使用及问题 ###

既然auto\_ptr是资源管理权限的转移从而造成拷贝赋值发生指针悬空问题，那么**unique\_ptr设计就很粗暴——防拷贝，直接不允许拷贝和赋值**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]

### <2>unique\_ptr模拟实现 ###

//2.unique_ptr
    template<class T>
    class unique_ptr {
        
    public:
    	unique_ptr(T* ptr = nullptr)
    		:_ptr(ptr)
    	{
        	}
    
    	~unique_ptr()
    	{
        
    		if (_ptr)
    			delete _ptr;
    	}
    
    	T& operator*() {
         return *_ptr; }
    	T* operator->() {
         return _ptr; }
    
    private:
    	//C++98防拷贝方式：拷贝构造和赋值构造只声明不实现+private私有
    	unique_ptr(unique_ptr<T> const &);
    	unique_ptr& operator=(unique_ptr<T> const &);
    	
    	//C++11防拷贝的方式：delete
    	unique_ptr(unique_ptr<T> const &) = delete;
    	unique_ptr& operator=(unique_ptr<T> const &)=delete;
    
    	T* _ptr;
    };

## 3.3 std::shared\_ptr ##

前面两个指针的使用场合具有局限性，为了能够支持更靠谱的拷贝C++11提供了shared\_ptr

### <1> shared\_ptr使用 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]  
shared\_ptr实现原理：**shared\_ptr通过引入引用计数器来实现多个shared\_ptr对象共享资源**。

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

### <2>shared\_ptr模拟实现 ###

1.  pCount引用计数器设计

*  static静态成员 ，如果是静态的，意味着所有对象只有一个计数器，无法做到不同对象有自己计数器
 *  栈上开辟的变量 栈上开辟的可以解决每个对象有自己的计数器，但是shared\_ptr对象共享同一个资源发生赋值拷贝更改计数器时，计数器不共享就会引发内存泄漏
 *  显然**堆上开辟**一个pCount最为合适！这样不同对象有自己的计数器，多个对象  
    共享同一个资源，多个对象指向同一个计数器，无论±都可以共享了

1.  线程安全问题

*  智能指针对象中**引用计数是多个智能指针对象共享**的，**两个线程中智能指针的引用计数同时++或–**，这个**操作不是原子的**，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以**智能指针中引用计数++、–是需要加锁的**，也就是说引用计数的操作是线程安全的。
 *  智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。这个**不是智能指针要关心的问题**，就不考虑了。

#include<thread>
    #include<mutex>
    
    //3.shared_ptr
    template<class T>
    class shared_ptr {
        
    public:
    	shared_ptr(T* ptr = nullptr)
    		:_ptr(ptr)
    		,_pCount(new int(1))
    		,_pMutex(new std::mutex)
    	{
        }
    
    
    
    	~shared_ptr()
    	{
        
    		Release();
    	}
    
    	shared_ptr(const shared_ptr<T>& sp)
    		:_ptr(sp._ptr)
    		, _pCount(sp._pCount)
    		, _pMutex(sp._pMutex)
    	{
        
    		AddRefCount();
    	}
    
    	shared_ptr& operator=(const shared_ptr<T>& sp)
    	{
        
    		//自己给自己赋值
    		if (this != &sp)
    		{
        
    			//释放管理的旧资源
    			Release();
    
    			//共享管理的新资源
    			_ptr = sp._ptr;
    			_pCount = sp._pCount;
    			_pMutex = sp._pMutex;
    
    			//引用计数器++
    			AddRefCount();
    		}
    
    		return *this;
    	}
    
    	T& operator*() {
         return *_ptr; }
    	T* operator->() {
         return _ptr; }
    
    	T* Get() {
         return _ptr; }
    	int use_count() {
         return *_pCount; }
    
    private:
    	void Release()
    	{
        
    		//给锁加一个flag，如果直接删除没法加锁解锁
    		bool deleteFlag = false;
    
    		//引用计数-1后如果为0代表是最后一个资源需要释放,这里需要加锁
    		_pMutex->lock();
    		if (--(*_pCount) == 0)
    		{
        
    			delete _ptr;
    			delete _pCount;
    			deleteFlag = true;
    		}
    		_pMutex->unlock();
    
    		//如果资源释放，锁也要释放
    		if (deleteFlag == true)
    			delete _pMutex;
    	}
    
    	void AddRefCount()
    	{
        
    		_pMutex->lock();
    		++(*_pCount);
    		_pMutex->unlock();
    	}
    
    private:
    	T* _ptr;
    	int* _pCount;	//堆上开辟引用计数器
    	std::mutex* _pMutex;	//互斥锁
    };

测试

void TestSharedPtrFunc(shared_ptr<Date>& sp, size_t n)
    {
        
    	std::cout << sp.Get() << std::endl;
    	for (size_t i = 0; i < n; ++i)
    	{
        
    		//1.这里智能指针管理的资源是线程安全的，无论多少个线程+-多少次
    		shared_ptr<Date> copy(sp);
    
    		//2.但是智能指针访问的资源不是线程安全的，2n次后结果不可预测
    		sp->day++;
    		sp->month++;
    		sp->year++;
    	}
    }
    
    void TestSharedPtr()
    {
        
    	//2.shared_ptr模拟实现测试
    	shared_ptr<Date> sp(new Date);
    	shared_ptr<Date> copy(sp);
    	shared_ptr<Date> sp2 = sp;
    
    	std::cout << "ref count: " << sp.use_count() << std::endl;
    	std::cout << "ref count: " << copy.use_count() << std::endl;
    	std::cout << "ref count: " << sp2.use_count() << std::endl;
    
    	//3.多线程测试
    	shared_ptr<Date> sp3(new Date);
    	std::cout << sp3.Get() << std::endl;
    	std::cout << sp3.use_count() << std::endl;	//开始计数器是1
    	sp3->day = sp3->month = sp3->year = 0;
    	size_t n = 100000;
    	std::thread t1(TestSharedPtrFunc, sp3, n);
    	std::thread t2(TestSharedPtrFunc, sp3, n);
    	
    	t1.join(); 
    	t2.join();
    	
    	std::cout << sp3->year << std::endl;
    	std::cout << sp3->month << std::endl;
    	std::cout << sp3->day << std::endl;
    
    	std::cout << sp3.use_count() << std::endl;	//结束后线程安全计数器还是1
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]

### <3> 循环引用问题 ###

//循环引用
    void TestRecrSharedPtr()
    {
        
    	struct ListNode {
        
    		int _val;
    		std::shared_ptr<ListNode> _next;
    		std::shared_ptr<ListNode> _prev;
    		~ListNode()
    		{
        
    			std::cout << "~ListNode()" << std::endl;
    		}
    	};
    
    	std::shared_ptr<ListNode> node1(new ListNode);
    	std::shared_ptr<ListNode> node2(new ListNode);
    
    	std::cout << node1.use_count() << std::endl;	
    	std::cout << node2.use_count() << std::endl;	
    	node1->_next = node2;
    	node2->_prev = node1;
    	std::cout << node1.use_count() << std::endl;
    	std::cout << node2.use_count() << std::endl;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]

循环引用分析：

1.  node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
2.  node1的\_next指向node2，node2的\_prev指向node1，引用计数变成2。
3.  node1和node2析构，引用计数减到1，但是\_next还指向下一个节点。但是\_prev还指向上一个节点。
4.  也就是说\_next析构了，node2就释放了。
5.  也就是说\_prev析构了，node1就释放了。
6.  但是\_next属于node1的成员，node1释放了，\_next才会析构，而node1由\_prev管理，\_prev属于node2成员，所以这就叫循环引用，谁也不会释放  
    ![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]

## 3.4 std::weak\_ptr ##

为了解决循环引用问题，weak\_ptr就出现了

void TestWeakPtr()
    {
        
    	struct ListNode {
        
    		int _val;
    		std::weak_ptr<ListNode> _next;
    		std::weak_ptr<ListNode> _prev;
    		~ListNode()
    		{
        
    			std::cout << "~ListNode()" << std::endl;
    		}
    	};
    
    	std::shared_ptr<ListNode> node1(new ListNode);
    	std::shared_ptr<ListNode> node2(new ListNode);
    
    	std::cout << node1.use_count() << std::endl;
    	std::cout << node2.use_count() << std::endl;
    	node1->_next = node2;
    	node2->_prev = node1;
    	std::cout << node1.use_count() << std::endl;
    	std::cout << node2.use_count() << std::endl;
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]  
weak\_ptr实现原理就是只保存shared\_ptr管理的指针，而不增加引用计数，都是搭配shared\_ptr使用的

// 跟其他智能指针有本质区别
    	// 不支持RAII,不释放资源
    	// 专门为解决shared_ptr循环引用而存在
    	// 不增加引用计数
    	template<class T>
    	class weak_ptr
    	{
        
    	public:
    		weak_ptr()
    			:_ptr(nullptr)
    		{
        }
    
    		weak_ptr(const shared_ptr<T>& sp)
    			:_ptr(sp.get())
    		{
        }
    
    		weak_ptr& operator=(const shared_ptr<T>& sp)
    		{
        
    			_ptr = sp.get();
    
    			return *this;
    		}
    
    		T& operator*()
    		{
        
    			return _ptr;
    		}
    
    		T* operator->()
    		{
        
    			return _ptr
    		}
    	private:
    		T* _ptr;
    	};

# 四、总结 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70]: /images/20220829/a123cbcd1cd9496f87d85a509174d5f2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 1]: /images/20220829/ae1bb2fd09d249c0b950b97f9e0df2f3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 2]: /images/20220829/aa8d118900694121a1c9057391e30f68.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 3]: /images/20220829/932f7f69dd8e4cb293c00fec705fa29b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 4]: /images/20220829/32daed1fd55d4ca18f9183f94a62333a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 5]: /images/20220829/6035ff06310a42eb91a28141025e83b6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 6]: /images/20220829/2f3509b61b88452d812e9477aeabb673.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 7]: /images/20220829/8db44eb4b12a4c208527e776d286838b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 8]: /images/20220829/6c4b7f041889491483909992ef0cbac5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwMDc2MDIy_size_16_color_FFFFFF_t_70 9]: /images/20220829/abe3300175a24512bf1050dec9cd9da3.png