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

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

使用智能指针，通常是因为以下两个场景，用一段代码模拟演示：

问题分析：

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的使用及问题

<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;
}

总结：
auto_ptr只是将对象中资源的管理权限进行转移，并将对象中的指针置空，因此不建议使用！

3.2 std::unique_ptr

<1>unique_ptr使用及问题

既然auto_ptr是资源管理权限的转移从而造成拷贝赋值发生指针悬空问题，那么unique_ptr设计就很粗暴——防拷贝，直接不允许拷贝和赋值

<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使用

shared_ptr实现原理：shared_ptr通过引入引用计数器来实现多个shared_ptr对象共享资源。

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

<2>shared_ptr模拟实现

1. pCount引用计数器设计

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

2. 线程安全问题

• 智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或–，这个操作不是原子的，引用计数原来是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

}

<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;
}

循环引用分析：

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成员，所以这就叫循环引用，谁也不会释放
   

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;
}

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;
	};

四、总结