【C++】智能指针

🌈个人主页：秦jh_-CSDN博客
🔥 系列专栏：https://blog.csdn.net/qinjh_/category_12575764.html?spm=1001.2014.3001.5482

 ​ 

目录

智能指针的使用及原理

RAII

std::auto_ptr 

 std::unique_ptr

std::shared_ptr

模拟shared_ptr

 std::shared_ptr的线程安全问题

std::shared_ptr的循环引用 

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

内存泄漏 

 内存泄漏分类（了解）

如何避免内存泄漏

前言

    💬 hello! 各位铁子们大家好哇。

             今日更新了C++智能指针的相关内容
    🎉 欢迎大家关注🔍点赞👍收藏⭐️留言📝

智能指针的使用及原理

RAII

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

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

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

上图中，嵌套了多层try，代码很难看。下面模拟智能指针思想进行解决。

 如果Division抛异常了，sp1，sp2出了作用域，就调用析构函数释放。如果sp2出异常了，sp1出了作用域也会释放。

  总结一下智能指针的原理： 1. RAII特性 2. 重载operator*和opertaor->，具有像指针一样的行为。

智能指针最大的问题是拷贝问题：

比如上面的sp2拷贝构造sp1，这样就会析构两次，也就是浅拷贝。可是这里又不能进行深拷贝，因为这里是模拟指针的行为，指针要的就是浅拷贝，这样才能共同管理同一资源。

std::auto_ptr 

C++98版本的库中就提供了auto_ptr的智能指针。下面演示auto_ptr的使用及问题。

auto_ptr的实现原理：管理权转移的思想

 auto_ptr需要包头文件<memory>

如上图，拷贝构造的时候转移管理权，此时sp1就悬空了。如果别人不了解这个特性，转移管理权后，去访问sp1，程序就会崩溃。

结论：auto_ptr是一个失败设计，很多公司明确要求不能使用auto_ptr

 std::unique_ptr

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

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

如上图，unique_ptr不支持拷贝构造。 

 如果想获取原生指针，也是可以获取的。通过get成员函数即可。

还可以调用 operator-> 

 如果是多个对象，可以用 类型[] 实例化。底层释放的时候他也会调用delete[] 。

auto_ptr：管理权转移，被拷贝对象会悬空，有风险，不建议使用。

unique_ptr：不支持拷贝，没有风险，建议使用，但是功能不全，此时就又有std::shared_ptr 

std::shared_ptr

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

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

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

share_ptr就支持拷贝构造了。 

use_count可以查看引用计数。 

make_shared和make_pair的使用一样，构造后返回一个对象。 

模拟shared_ptr

如上图，同一个类型的模板，对应的资源不同，对应的引用计数也要不同。所以可以用指针指向这个计数，这样计数就可以开多个。管理同一个资源的不同对象时，用同一个指针指向这个计数即可。

模拟代码：

#pragma once
#include<atomic>
#include<functional>

namespace bit
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new atomic<int>(1))
		{}

		template<class D>
		shared_ptr(T* ptr, D del)
			: _ptr(ptr)
			, _pcount(new atomic<int>(1))
			, _del(del)
		{}

		// sp2(sp1)
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			(*_pcount)++;
		}

		// sp1 = sp3;
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this != &sp)
			if (_ptr != sp._ptr)
			{
				this->release();

				_ptr = sp._ptr;
				_pcount = sp._pcount;

				++(*_pcount);
			}

			return *this;
		}

		void release()
		{
			if (--(*_pcount) == 0)
			{
				// 最后一个管理的对象，释放资源
				//delete _ptr;
				_del(_ptr);

				delete _pcount;
			}
		}

		~shared_ptr()
		{
			release();
		}

		int use_count()
		{
			return *_pcount;
		}

		T& operator*()
		{
			return *_ptr;
		}

		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		atomic<int>* _pcount;

		function<void(T*)> _del = [](T* ptr) {delete ptr; };
	};
}

 std::shared_ptr的线程安全问题

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

引用计数++，--需要加锁，不过我们可以用 atomic 更加方便。

std::shared_ptr的循环引用 

循环引用分析：

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属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev 属于node2成员，所以这就叫循环引用，谁也不会释放。 

如何解决循环引用的问题？用 weak_ptr

weak_ptr 不支持RAII，不单独管理资源。是专门用来辅助解决shared_ptr循环引用问题的。

本质：赋值或拷贝时，只指向资源，但是不增加shared_ptr 的引用计数。

如果不是new出来的对象如何通过智能指针管理呢？其实shared_ptr设计了一个删除器来解决这个问题 

可以通过lambda表达式或者仿函数传入定制删除器。

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

1. C++ 98 中产生了第一个智能指针auto_ptr.
2. C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr.
3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版。
4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost 的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。 

内存泄漏 

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

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

 内存泄漏分类（了解）

 C/C++程序中一般我们关心两种方面的内存泄漏：

堆内存泄漏(Heap leak)：

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

系统资源泄漏：

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

如何避免内存泄漏

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

 总结一下: 内存泄漏非常常见，解决方案分为两种：

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