【C++】详细版 RAII技术的应用之智能指针(智能指针发展历程和简单模拟实现介绍)

前言

一、智能指针有什么用？

二、什么是RAII(智能指针的底层思想)？

三、智能指针的发展历程以及模拟实现

1.auyo_ptr（C++98）

2.unique_ptr（C++11）

3.shared_ptr（C++11）

前言

C++中的智能指针是一种管理内存的工具，它可以自动地跟踪和管理所指向的内存块。智能指针通常用于替代手动管理内存的机制，避免内存泄漏和野指针等问题。

一、智能指针有什么用？

下面我们来看一种场景：

#include <iostream>
using namespace std;
double Division(int x, double y)
{
	cin >> x >> y;
	if (0 == y)
		throw invalid_argument("除数为0无法计算");
	return x / y;
}
void func()
{
	pair<int, string>* p1 = new pair<int, string>(7, "CSDN");
    int x;
    double y;
    cin >> x >> y;
	cout << Division(x, y) << endl;
	delete p1;
	p1 = nullptr;
}
int main()
{
	try
	{
		func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

从上面代码可以分析出：如果Dvision函数中抛异常的话，那么p1指向的空间内存就无法释放，造成内存泄露。因此此时就需要一个智能指针对p1指向的空间内存进行自动释放。因此我们可以这样做：利用对象的生命周期来控制手动开辟的内存资源。下面我们来简单实现一下着种方法：

#include <iostream>
using namespace std;
class A
{
public:
	A(pair<int, string>* ptr)
		:_ptr(ptr)
	{}
    ~A()
    {
    cout << "delete" << endl;
    }
private:
	pair<int, std:string>* _ptr;
};
double Division(int x, double y)
{
	cin >> x >> y;
	if (0 == y)
		throw invalid_argument("除数为0无法计算");
	return x / y;
}
void func()
{
	pair<int, string>* p1 = new pair<int, string>(7, "CSDN");
    A a(p1);
    int x;
    double y;
    cin >> x >> y;
	cout << Division(x, y) << endl;
	delete p1;
	p1 = nullptr;
}
int main()
{
	try
	{
		func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

1.当Division函数中不抛异常的情况，代码运行结果如下：

2.当Division函数中抛异常的情况，代码运行结果如下：

由此可见，将p1指向的资源托管给对象a控制是利于其资源释放的，p1指向的资源会随着对象a的销毁而销毁。

二、什么是RAII(智能指针的底层思想)？

智能指针是RAII技术的应用。

RAII（Resource Acquisition Is Initialization）是一种 利用对象生命周期来控制程序资源（如内

存、文件句柄、网络连接、互斥量等等）的简单技术。

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

对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做

法有两大好处：

first：不需要显式地释放资源。

second：采用这种方式，对象所需的资源在其生命期内始终保持有效。

三、智能指针的发展历程以及模拟实现

智能指针的大体是有三个阶段的发展：第一阶段C++98的auto_ptr；第二阶段C++11的unique_ptr；第三阶段C++11中的shared_ptr。通过不断创新与努力C++11最终发布了shared_ptr,这也是智能指针的最终版本，是最优的。

我们分别来模拟实现一下这几种智能指针，以及对它们做出分析。

在此之前我们必须要明白其实智能指针是一个类对象，该类封装了所需要管理的资源，以及内部实现了具有指针功能的运算符重载成员函数（operator* operator->）。

1.auyo_ptr（C++98）

auto_ptr 的实现原理：管理权转移的思想，下面简化模拟实现了一份 keke::auto_ptr 来了解它的原 理

#include <iostream>
using namespace std;
namespace keke
{
	template<class T >
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr)
			:_ptr(ptr)
		{}
		auto_ptr(auto_ptr& ap)
			:_ptr(ap._ptr)
		{
			//资源管理权转移
			ap._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr& ap)
		{
			//检查是否为自己给自己赋值，如果是的话那么不进行赋值
			if (_ptr != ap._ptr)
			{
				//释放被赋值对象里的资源
				if (_ptr)
					delete _ptr;
				//将对象ap的资源转移给被赋值对象
				_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;
	};
}
int main()
{
	keke::auto_ptr<int> ap1(new int(5));
	keke::auto_ptr<int> ap2(ap1);
	++(*ap1);//由于ap1将资源权限转移给了ap2，则ap1_ptr==nullptr
	         //导致读取数据错误！

	++(*ap2);
	return 0;
}

基于上面的问题，auto_ptr是不建议被使用的。

2.unique_ptr（C++11）

unique_ptr的实现原理： 简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr 来了解它的原

unique_ptr是在auto_ptr的基础上改进的。只是将auto_ptr模拟实现中的拷贝构造函数和赋值运算符重载访问权限改为private,或者是在两个默认成员函数后加=delete。

template<class T >
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		unique_ptr(unique_ptr& up) = delete;
		unique_ptr<T>& operator=(unique_ptr& up) = delete;
		~unique_ptr()
		{
			if (_ptr)
				delete _ptr;
		}
		//要像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

智能指针unique_ptr对于不需要拷贝的场景适用，但是需要拷贝的场景则不能使用。

3.shared_ptr

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

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

举一个例子：放学后最后一个走出教室的同学需要把教室的门上锁。

1. shared_ptr在其内部， 给每个资源都维护了着一份计数，用来记录该份资源被几个对象共

享。

2. 在 对象被销毁时 ( 也就是析构函数调用 )，就说明自己不使用该资源了，对象的引用计数减

一。

3. 如果引用计数是 0，就说明自己是最后一个使用该资源的对象， 必须释放该资源；

4. 如果不是 0，就说明除了自己还有其他对象在使用该份资源， 不能释放该资源，否则其他对

象就成野指针了。

#include <iostream>
using namespace std;
namespace keke
{
	template<class T >
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			,_pCount(new int(1))
		{}
		shared_ptr(shared_ptr& sp)
			:_ptr(sp._ptr)
			,_pCount(sp._pCount)
		{
			++(*_pCount);
		}
		
		shared_ptr<T>& operator=(shared_ptr& sp)
		{

			if (_ptr != sp._ptr)//检查是否为自己给自己赋值
				Release();
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			++(*_pCount);
			return *this;
		}
		void Release()
		{

			if (0 == --(*_pCount) && _ptr)
			{
				cout << "delete" << endl;
				delete _ptr;
				delete _pCount;
			}
		}
		~shared_ptr()
		{
			Release();
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		int use_count()
		{
			return *_pCount;
		}
	private:
		T* _ptr;
		int* _pCount;
	};
}
int main()
{
	keke::shared_ptr<string> sp1(new string("CSDN"));
	keke::shared_ptr<string> sp2 = sp1;
	keke::shared_ptr<string> sp3(sp1);
	
	keke::shared_ptr<pair<int, string>> sp4(new pair<int, string>(5, "CSDN"));
	keke::shared_ptr<pair<int, string>> sp5(sp4);
	return 0;
}

运行结果如下：