C++11新特性（四）——智能指针

---

一、什么是智能指针

在以往的代码编写中，内存资源管理问题一直是非常麻烦的。比如：

1. malloc出来的空间，没有进行释放，存在内存泄漏的问题。
2. 异常安全问题。如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全。

内存泄漏是非常可怕的，这也正是C/C++比较麻烦的地方，所以大佬们就想用一个指针，能够管理资源，并且能够自动释放资源，这种指针就叫做智能指针。智能指针是采用RAII这种技术来实现的。

1.1 RAII

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

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

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

二、常见内存泄漏

2.1 什么是内存泄漏，内存泄漏的危害

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

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

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	// 2.异常安全问题
	int* p3 = new int[10];
	Func(); // 这里Func函数抛异常导致 delete[] p3未执行，p3没被释放.
	delete[] p3;
}

2.2 常见内存泄漏分类

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

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

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

如何避免内存泄漏

1. 工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 采用检测工具

三、智能指针发展史

3.1 智能指针原理

智能指针就是用RAII思想创建的一个类，能够像指针一样使用（重载运算符）。

1. RAII特性
2. 重载operator*和opertaor->，具有像指针一样的行为。

3.2 auto_ptr

这是C++98的时候出现的，但是功能不够完善
auto_ptr 实现原理

• RAII思想，构造函数接受一个管理资源的指针，析构函数释放资源
• 管理权转移的思想，当有拷贝构造或者赋值的时候，将原对象的值赋给新对象，原对象指针置空。
  也就是说只有一个指针指向要管理的资源。

但是这样的话不能完全解决资源问题，使得被拷贝对象指针悬空，比如：

#define _CRT_SECURE_NO_WARNINGS 1

#include 
using namespace std;


template<class T>
class AutoPtr
{

public:
	AutoPtr(T* p = nullptr):_ptr(p)
	{}

	AutoPtr(AutoPtr& ap)
	{
		// 资源转移，只有一个指针管理
		_ptr = ap._ptr;
		ap._ptr = nullptr;
	}

	AutoPtr<T>& operator=(const AutoPtr& ap)
	{
		// 资源转移
		if (this != &ap)
		{
			if (_ptr != nullptr)
				delete _ptr;
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		return *this;
	}

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

	~AutoPtr()
	{
		if (_ptr != nullptr)
			delete _ptr;
	}
private:
	T* _ptr;
};



int main()
{
	AutoPtr<int> ap1(new int(1));
	AutoPtr<int> ap2(ap1);
	// 现在再从实现原理层来分析会发现，这里拷贝后把ap1对象的指针赋空了，导致ap1对象悬空
	// 通过ap1对象访问资源时就会出现问题。
	cout << *ap1 << endl;
	cout << *ap2 << endl;

	return 0;
}

3.3 unique_ptr

C++98的auto_ptr很少被人使用，知道C++11新标准出来，从boost库引进了更加全面的智能指针。
unique_ptr/ shared_ptr/ weak_ptr

unique_ptr就是对auto_ptr 的改进，使用的是一种简单粗暴的防拷贝思想，一个资源只有一个指针管理。

模拟实现：

template<class T>
class UniquePtr
{
public:
	UniquePtr(T* ptr = nullptr):_ptr(ptr)
	{}
	~UniquePtr()
	{
		if (_ptr != nullptr)
		{
			delete _ptr;
		}
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	UniquePtr(const UniquePtr& up) = delete;
	UniquePtr<T>& operator=(const UniquePtr& up) = delete;
private:
	T* _ptr;
};

3.4 shared_ptr

shared_ptr是最常用有效并且支持拷贝的一个智能指针。

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

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

引用计数不能使用静态变量，这样所以的对象的引用计数都相同了，但其实需要的是对同一份资源的管理，用同一个变量计数；每一份资源独有一个计数。
这就要使用到堆上开辟的空间来进行引用计数了。

template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr):_ptr(ptr),
		_pRefCount(new int(1))
	{}
	void Release()
	{
		if (--(*_pRefCount) == 0 && _ptr != nullptr)
		{
			delete _ptr;
			delete _pRefCount;
		}
	}
	~SharedPtr()
	{
		Release();
	}

	void AddRef()
	{
		++(*_pRefCount);
	}
	// 拷贝构造函数
	SharedPtr(const SharedPtr& sp)
		:_ptr(sp._ptr),
		_pRefCount(sp._pRefCount)
	{
		AddRef();
	}
	// 赋值运算符重载
	SharedPtr& operator=(const SharedPtr& sp)
	{
		if (_ptr != sp._ptr) // 同一份资源不用赋值
		{
			Release(); // 释放自己的资源

			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			
			AddRef(); // 增加引用计数
		}
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pRefCount; // 引用计数
};

3.5 智能指针的线程安全问题

多线程的时候，对引用计数的加减操作是线程不安全的。

1. 引用计数放在堆上，多个线程能够同时访问，会导致加加，减减冲突不一致。
2. 智能指针管理的资源也是在堆上，对资源操作的时候也有线程安全。

但是2 的问题不是智能指针需要解决，也管不了，因为访问该资源是在智能指针类外部。

但是1的问题可以通过加锁来解决。但是这个锁也类似引用计数，每份资源只有一个，所以需要在堆上开辟。

#include 
template<class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr):_ptr(ptr),
		_pRefCount(new int(1)),
		_pmtx(new mutex)
	{}
	void Release()
	{
		_pmtx->lock();
		bool flag = false;
		if (--(*_pRefCount) == 0 && _ptr != nullptr)
		{
			delete _ptr;
			delete _pRefCount;
			flag = true;
		}
		_pmtx->unlock();
		if (flag) delete _pmtx;
	}
	~SharedPtr()
	{
		Release();
	}

	void AddRef()
	{
		_pmtx->lock();

		++(*_pRefCount);

		_pmtx->unlock();
	}
	SharedPtr(const SharedPtr& sp)
		:_ptr(sp._ptr),
		_pRefCount(sp._pRefCount),
		_pmtx(sp._pmtx)
	{
		AddRef();
	}

	SharedPtr& operator=(const SharedPtr& sp)
	{
		if (_ptr != sp._ptr) // 同一份资源不用赋值
		{
			Release(); // 释放自己的资源

			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pmtx = sp._pmtx;
			AddRef();
		}
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pRefCount; // 引用计数
	mutex* _pmtx;
};

3.6 定制删除器

现在又有一个新问题，如果要管理的资源是多个对象怎么办，比如管理一个数组，文件指针，malloc。
这就需要定制一个删除器来解决，删除器得是可调用对象，传入删除资源的函数。

对应unique_ptr而言，需要传入一个删除器的类型，所以使用仿函数更好。

template<class T, class D = default_del<T>>
class UniquePtr
{
public:
	UniquePtr(T* ptr = nullptr):_ptr(ptr)
	{}
	~UniquePtr()
	{
		if (_ptr != nullptr)
		{
			D del;
			del(_ptr);
		}
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	UniquePtr(const UniquePtr& up) = delete;
	UniquePtr<T>& operator=(const UniquePtr& up) = delete;
private:
	T* _ptr;
};

有库里面实现shared_ptr的实现比较复杂，所以它是在构造函数的时候传入删除器对象的。

class A
{
public:
	~A()
	{
		cout << "~A()" << endl;
	}
private:
	int _a1 = 0;
	int _a2 = 0;
};
template<class T>
struct DeleteArray
{
	void operator()(const T* ptr)
	{
		cout << "delete[]:" << ptr << endl;
		delete[] ptr;
	}
};

struct DeleteFile
{
	void operator()(FILE* ptr)
	{
		cout << "fclose:" << ptr << endl;
		fclose(ptr);
	}
};

int main()
{
	// 删除器在类模板参数给 -- 类型
	UniquePtr<A> up1(new A);
	UniquePtr<A, DeleteArray<A>> up2(new A[10]);
	UniquePtr<FILE, DeleteFile> up3(fopen("test.txt", "w"));

	// 删除器在构造函数的参数给 -- 对象
	std::shared_ptr<A> sp1(new A);
	std::shared_ptr<A> sp2(new A[10], DeleteArray<A>());
	std::shared_ptr<FILE> sp3(fopen("test.txt", "w"), DeleteFile());
	// 也可以传入其他可调用对象
	std::shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p) {fclose(p); });

}

3.7 循环引用问题

下面一段代码显示循环引用问题

struct ListNode
{
	int _val;
	SharedPtr<ListNode> _next;
	SharedPtr<ListNode> _prev;


	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	SharedPtr<ListNode> n1(new ListNode);
	SharedPtr<ListNode> n2(new ListNode);

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	// 循环引用
	n1->_next = n2;
	n2->_prev = n1;

	// 获取智能指针里面的引用计数
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	return 0;
}

没有调用析构函数，说明没有释放资源。这是为什么呢？

1. 首先使用shared_ptr管理结点， 结点里面有同类型智能指针管理的指针。
2. 当执行语句n1->_next = n2;n2->_prev = n1;的时候，两个结点进行了关联，n1->_next来管理n2，n2->_prev来管理n1，它们都是shared_ptr智能指针，引用计数都增加为2。n1、n2的资源分别有两个智能指针管理。
3. 但是，只有当引用计数减少到0的时候才会释放资源。
4. 当n2的生命周期结束的时候，n2减少一个引用计数，但是不会释放空间，同理n1也减少一个引用计数，也不会释放空间。
5. 因为想要n2释放空间，得n1->_next销毁；n1_next想要销毁，得n1被销毁；n1想要销毁，得n2->_prev被销毁；n2->_prev想要被销毁，得n2被销毁… 所以有了循环引用，无法释放空间。

这就需要用到weak_ptr

3.8 weak_ptr

它不是传统意义上的智能指针，因为它没有RAII思想，没有一个接受原生指针的构造函数。

使用它不会增加引用计数，只能解引用管理的资源，不参与管理资源。可以像智能指针那样使用。
它就可以很好的解决循环引用这个问题。

struct ListNode
{
	int _val;
	//SharedPtr _next;
	//SharedPtr _prev;
	
	std::weak_ptr<ListNode> _next;
	std::weak_ptr<ListNode> _prev;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	//SharedPtr n1(new ListNode);
	//SharedPtr n2(new ListNode);
	std::shared_ptr<ListNode> n1(new ListNode);
	std::shared_ptr<ListNode> n2(new ListNode);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	// 循环引用
	n1->_next = n2;
	n2->_prev = n1;

	// 获取智能指针里面的引用计数
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	return 0;
}

// 简略版weak_ptr
template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}

	weak_ptr(const shared_ptr<T>& sp)
		:_ptr(sp.get()) // 获得sp._ptr
	{}

	weak_ptr<T>& operator=(const shared_ptr<T>& sp)
	{
		_ptr = sp.get();

		return *this;
	}

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

	T* operator->()
	{
		return _ptr;
	}


private:
	T* _ptr;
};