目录

一.智能指针的概念

（一）.智能指针的历史

（二）.智能指针的使用

插曲.auto_ptr

①unique_ptr

②shared_ptr

③weak_ptr

二.智能指针的实现

三.智能指针的缺陷

（一）.循环引用

（二）.定制删除器

---

一.智能指针的概念

智能指针指在通过RAII（Resource Acquisition Is Initialization，即资源获取就是初始化）技术，免去手动释放指针指向资源的步骤，希望能自动释放内存资源。底层而言，就是通过封装一个类，使用析构函数来释放资源。

当类对象出作用域被销毁时，会自动调用析构函数从而完成释放资源。

（一）.智能指针的历史

最初的智能指针是C++98提出来的auto_ptr，不过因为使用时缺陷很大，Beman G.Dawes（C++委员会成员之一）所成立的boost社区（专门面向C++程序员，提供许多免费好用的自制库）贡献了scoped_ptr、shared_ptr、weak_ptr被C++11采纳，修改为官方的unique_ptr、shared_ptr、weak_ptr。

（二）.智能指针的使用

头文件<memory>

ps:虽然下面的auto_ptr、unique_ptr之类均是库模板类，但为了便于理解均称为指针。 

插曲.auto_ptr

对于auto_ptr，小编认为它很鸡肋。虽然它也能够自动释放资源，但是一旦对类进行拷贝，那么会将资源转移给拷贝对象，而被拷贝者将失去资源（很像移动拷贝）。因此，一旦后续有调用被拷贝对象，那将引发巨大安全问题。

①unique_ptr

顾名思义，“独一无二”的指针，即只能有一个指针指向申请的资源空间，不存在两个指针同时指向一个空间，可以说这个就是C++11中对auto_ptr的改进，将它作为智能指针的一种形式。

与auto_ptr不同，unique_ptr禁止拷贝行为，当然赋值也是禁止的。

②shared_ptr

“可以分享”的指针，说明允许拷贝与赋值行为，即允许多个指针指向同一片空间。

同时不管有多少指针指向一个空间，这个空间只会释放一次。 

std::shared_ptr<int> p1(new int);
std::shared_ptr<int> p2;
p2 = p1;//不会有任何问题，资源只会释放一次

③weak_ptr

“无权”的指针（小编认为这里翻译成无权更好，而不是虚弱），该指针不会释放指向的资源，用于解决shared_ptr的一些缺陷（循环引用），第三部分会详细讲解。

二.智能指针的实现

 这里我们重点实现shared_ptr。

首先定义一个模板类，其中一个指针成员负责指向申请的空间，析构函数中delete该指针成员即可完成资源自动释放。

但是难点在于怎么拷贝，如果单纯拷贝的话那会引起资源重复释放的问题。

因此我们采用引用计数的方式解决。

专门动态开辟一个int空间用于记录我们申请的资源空间有多少个指针指向。

当调用构造、拷贝、赋值时计数++，调用析构时计数--，直到计数空间值为0时真正释放资源。

值得注意的是，赋值需要考虑被赋值者原资源空间以及原来的计数空间。

代码如下：

template<class T>
class Shared_ptr
{
	typedef Shared_ptr<T> Self;
private:
    bool Destory()//销毁
	{
		if (pCount == nullptr || (*pCount) == 0) return false;

		(*pCount)--;//计数--

		if ((*pCount) == 0 && _ptr)
		{
			delete _ptr;
			delete pCount;
		}
		_ptr = nullptr;
		pCount = nullptr;
		return true;
	}
public:
	Shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, pCount(new int(1))
	{}
	Shared_ptr(const Self& sp)//拷贝构造
		:_ptr(sp._ptr)
		, pCount(sp.pCount)
	{
		(*pCount)++;
	}

	Self& operator=(const Self& sp)//赋值
	{
		if (_ptr == sp._ptr) return *this;
		Destory();
		_ptr = sp._ptr;
		pCount = sp.pCount;
		(*pCount)++;
		return *this;
	}
	bool release()//释放本指针空间（还有其他指向时不释放空间）
	{
		return Destory();
	}
	~Shared_ptr()//析构
	{
		std::cout << "~" << std::endl;
		Destory();
	}

	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	T* get()
	{
		return _ptr;
	}
    bool expired()//检查是否过期（指向空间是否已被释放）
	{
        
		return pCount != nullptr && *pCount == 0;
	}
	size_t get_count() const
	{
		return *pCount;
	}
private:
	T* _ptr;//指向空间
	int* pCount;//指向计数空间
};

三.智能指针的缺陷

（一）.循环引用

shared_ptr隐藏了一个极大的bug。

看看下面代码：

class A {
public:
	~A() {
		std::cout << "析构" << std::endl;
	}
	std::shared_ptr<A> next;
	std::shared_ptr<A> prev;
	int i = 0;
};

int main()
{
	
	std::shared_ptr<A> p1(new A);
	std::shared_ptr<A> p2(new A);
	p1->next = p2;
	p2->prev = p1;

 	return EXIT_SUCCESS;
}

 正常情况下，应该会打印两次“析构”，分别是调用p1和p2析构函数delete指向空间时。

但实际是一个都没打印：

这是因为出现了循环引用的情况。

p1指向空间的next指向p2空间，导致p2空间的计数变成2，同理p2指向空间的prev指向p1空间，p1空间计数变成2。

但是当析构时只有p1和p2出栈，也就是分别调用一次析构函数，两个空间的计数均-1，变成1。此时并不会真正释放空间，但“明面上”又找不到指向这两个空间的指针。因为这两个堆空间又分别被对方堆空间上的指针指向，算是一种“死锁”吧。

画图如下：

解决方式：

专门定义一个模板类智能指针，只能指向空间但不能改变计数数量即可。

即weak_ptr（名字也就是这么来的）。

代码如下：

ps:小编采用的是将weak_ptr作为shared_ptr的友元类，也可以是普通模板类。

class Shared_ptr
{
	typedef Shared_ptr<T> Self;
	template<class T>
	friend class Weak_ptr;
    . . .
}

template<class T>
class Weak_ptr
{
	typedef Weak_ptr<T> Self;
	typedef Shared_ptr<T> Sptr;
public:
	Weak_ptr()
		:_ptr(nullptr)
	{}
	Weak_ptr(const Self& wp)
		:_ptr(wp._ptr)
		,pCount(wp.pCount)
	{}
	Weak_ptr(const Sptr& sp)
		:_ptr(sp._ptr)
		,pCount(sp.pCount)
	{}
	~Weak_ptr()
	{}
	Self& operator=(const Self& wp)
	{
		_ptr = wp._ptr;
		pCount = wp.pCount;
		return *this;
	}
	Self& operator=(const Sptr& sp)
	{
		_ptr = sp._ptr;
		pCount = sp.pCount;
		return *this;
	}
	bool expired()
	{
		return *pCount == 0;
	}
	T& operator*()
	{
		assert(!expired());
		return *_ptr;
	}
	T* operator->()
	{
		assert(!expired());
		return _ptr;
	}
private:
	T* _ptr;
	int* pCount;
};

（二）.定制删除器

细心的可能发现了，析构函数只有delete一种方式，那如果我们需要的是delete[]呢？

比如这种情况：

std::shared_ptr<A> p1(new A[5]);

这时将报错：

但如果是内置类型比如int又不会报错了。

这是因为有析构函数的存在，如果自定义类型（weak_ptr）没有析构函数那也不会报错。

下面我们仔细梳理一下：

如果自定义类型没有析构函数，那么对于编译器而言只需要把它按内置类型处理即可。

但对于有析构函数的自定义类型，编译器会根据new空间的个数，在空间之前再开辟4个字节记录该类型开辟的数量。当调用delete[]时会根据这个记录调用对应次的析构函数。

但因为我们使用的是delete，根据记录本应调用n次，而delete只会调用一次，与记录有冲突从而报错。

解决方式：

根据需要删除的对象，确定需要delete或delete[]，传一个仿函数给智能指针模板，删除时调用仿函数即可。

代码如下：

template<class T>//默认仿函数，默认使用delete
class DefaultDelete {
public:
	void operator()(T* _ptr) {
		delete _ptr;
	}
};

template<class T, class D = DefaultDelete<T>>//传一个默认的仿函数
class Shared_ptr
{
private:
    bool Destory()//销毁
	{
		. . .
		if ((*pCount) == 0 && _ptr)
		{
			D()( _ptr);
			delete pCount;
		}
		. . .
	}
    . . .
}

template<class T>//可以自制一个传delete[]
class Free {
public:
	void operator()(T* _ptr) {
		delete[] _ptr;
	}
};

值得注意的是，官方的shared_ptr是在构造函数中传仿函数对象，而unique_ptr是传仿函数类型给模板参数。

我不是一个伟大的程序员，我只是一个具有良好习惯的优秀程序员—— Kent Beck

---

如有错误，敬请斧正