C++11——智能指针

智能指针的介绍

智能指针是C++11中引入的标准库特性之一，智能指针是为了避免手动管理内存时常见的错误，比如内存泄漏、重复释放内存等问题。智能指针通过封装原生指针（裸指针）和自动释放内存的功能，让开发者更安全和高效地管理动态资源。

C++11为了解决手动管理内存时容易出现的内存泄漏问题，提供了三种主要的智能指针类型：

std::unique_ptr：用于独占所有权的智能指针。一个对象只能有一个unique_ptr指向它，且不能被通过拷贝构造来进行复制，但可以通过std::move转移所有权。
std::shared_ptr：用于共享所有权的智能指针。多个shared_ptr可以指向同一个对象，当最后一个指针销毁时，对象才会被删除。
std::weak_ptr：与shared_ptr配合使用，用于避免循环引用。它不影响引用计数，不能直接访问资源，但可以通过lock()获得一个有效的shared_ptr。

内存泄露

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

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

智能指针

RAII

RAII（Resource Acquisition Is Initialization，资源获取即初始化）是C++中一种非常重要的资源管理惯用法。其核心思想是将资源的获取与对象的生命周期绑定，通过对象的创建和销毁来自动管理资源的分配与释放（构造获取资源，析构释放资源）。RAII的主要目的是确保无论程序控制流如何变化，当内存资源在不再使用时，都能够被正确地释放。

下面是一个基于RAII思想设计出的一个简单的智能指针：

template<class T>
class SmartPtr
{
private:
	T* _ptr = nullptr;
public:
	SmartPtr(T* ptr)//构造时获取资源
		:_ptr(ptr)
	{}
	~SmartPtr()//析构时释放资源
	{
		if (_ptr != nullptr)//判断_ptr是否提前被释放，避免二次析构释放资源
		{
			delete _ptr;
		}
	}
    //重载*、->使得智能指针可以像原生指针一样正常使用
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
};

基于RAII思想，智能指针本质就是借助了对象来托管指针存放的资源。

对于对象来说，当其生命周期结束后会自动调用析构函数来释放资源，这对于处理内存泄露的问题十分方便，而通过使用智能指针，我们也不需要手动显示的去释放开辟的资源。

std::unique_ptr 智能指针

在C++11中首先引入了unique_ptr这一智能指针，一个对象不能由多个unique_ptr来管理，只能被一个unique_ptr来管理。此外，为了避免unique_ptr之间发生拷贝构造导致多个unique_ptr指向同一个对象，unique_ptr中的拷贝构造函数、以及赋值重载函数是不允许被使用的。

unique_ptr的简单模拟实现

template<class T>
class UniquePtr
{
private:
	T* _ptr = nullptr;
public:
	UniquePtr(T* ptr)//构造时获取资源
		:_ptr(ptr)
	{}
	~UniquePtr()//析构时释放资源
	{
		if (_ptr != nullptr)//判断_ptr是否提前被释放，避免二次析构释放资源
		{
			cout << "delete _ptr" << endl;
			delete _ptr;
		}
	}
	//禁用拷贝构造函数以及赋值重载函数
	UniquePtr(const UniquePtr<T>& uptr) = delete;
	UniquePtr<T>& operator= (const UniquePtr<T>& uptr) = delete;

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

以上对于unique_ptr智能指针进行了简单的模拟实现，实际上还有许多功能没有实现。关于unique_ptar主要需要注意的点，在于需要禁掉拷贝构造函数以及赋值重载函数的使用，避免多个unique_ptr同时指向同一个对象。

std::shared_ptr 智能指针

与unique_ptr不同的是，shared_ptr是可以允许多个shared_ptr智能指针同时指向同一个对象。

也就是shared_ptr中并没有禁用拷贝构造函数以及赋值重载函数。但为了避免二次析构释放资源的问题，shared_ptr还采取了其他策略。

shared_ptr的原理

shared_ptr智能指针可以指向同一个对象，这难免会有同一个对象资源重复被释放的问题，为了解决这个问题，shared_ptr中引进了新的成员变量。

C++11通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

在shared_ptr内部，通过成员变量，给每个资源都维护了着一份计数，用来记录该份资源被几个对象享。
在对象被销毁时(析构函数调用)，就说明自己不使用该资源了，对象的引用计数减1，当引用计数不为0时，说明仍然有对象对资源进行管理，只有当引用计数为0时才对管理资源进行释放。

shared_ptr的简单模拟实现

template<class T>
class SharedPtr
{
private:
	T* _ptr;
	int* _count;//记录管理资源空间的对象个数
public:
	SharedPtr(T* ptr = nullptr)
		:_ptr(ptr)
		,_count(new int(1))
	{}
	//拷贝构造
	SharedPtr(const SharedPtr<T>& sp)
	{
		if (*_count == 1)//资源管理对象只剩自身一个
		{
			~SharedPtr();
		}
		_ptr = sp._ptr;
		_count = sp._count;
		*_count += 1;
	}
	//赋值重载
	SharedPtr<T>& operator = (const SharedPtr<T>& sp)
	{
		if (this != &sp)//避免自身赋值
		{
			if (*_count == 1)//资源管理对象只剩自身一个
			{
				this->~SharedPtr();
			}
			_ptr = sp._ptr;
			_count = sp._count;
			*_count += 1;//管理资源对象加一
		}
		return *this;
	}
	~SharedPtr()
	{
		if (_ptr!=nullptr && *_count == 1)//_ptr不为空，且资源管理对象只剩自身一个
		{
			cout << "delete _ptr：" << _ptr << endl;
			cout << "delete _count：" << _count << endl;
			delete _ptr;
			delete _count;
		}
        else if (_ptr != nullptr && *_count > 1)//_ptr不为空，且资源管理对象不止一个
        {
	        *_count -= 1;//管理资源对象减一
        }
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
    T* get()const
    {
	    return _ptr;
    }
	friend ostream& operator<< (ostream& out, const SharedPtr<T>& sp)
	{
		out << sp._ptr;
		return out;
	}
};

shared_ptr的模拟实现比较需要注意的是，每个对象的资源释放问题，每次赋值重载需要考虑是否原先管理的资源是否需要释放资源。

std::shared_ptr的循环引用

在一些特定的场景下，shared_ptr的使用有时会出现问题，对于使用shared_ptr循环引用的场景，其不能正常实现对资源的管理。

struct ListNode
{
	int _data; 
	SharedPtr<ListNode> _prev;
	SharedPtr<ListNode> _next;
	~ListNode() 
	{ 
		cout << "~ListNode()" << endl;
	}
};

例如对于某一上双向链表中，将前后指针使用shared_ptr来管理资源，此时就会出现循环引用的问题。

如果将两链表节点相互连接起来，使得node1的节点的后继节点指向node2节点，node2的前驱节点指向node1，此时两节点中的指针成员相互被连接起来，node1以及node2节点的引用计数都为2

随着生命周期的结束，node1、node2的资源要被析构释放， 引用计数各自减为1，但是node1成员中的_next还是指向node2，node2中的_pre也还是指向node1，这会导致，node1中shared_ptr管理的_next的释放需要将node2释放，而node2中shared_ptr管理的_prev的释放需要将node1释放，导致两者相互制约，哪个都不会先释放。

而为了类似这种循环引用的问题，后续C++11又引入了新的智能指针，也就是第三个智能指针所提std::weak_ptr。

std::weak_ptr智能指针

weak_ptr智能指针用于解决shared_ptr中的循环引用问题，weak_ptr只能用于托管shared_ptr智能指针，其本质是在不增加引用计数的前提下接收shared_ptr中管理的资源。

使用weak_ptr托管shared_ptr时，管理相同资源时，其管理对象的个数的引用计数也不会增加计数，这避免了循环引用导致的问题。

weak_ptr的简单模拟实现

template<class T>
class WeakPtr
{
private:
	T* _ptr;
public:
	WeakPtr(const SharedPtr<T> & sp = nullptr)
		:_ptr(sp.get())
	{}
	WeakPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		_ptr = sp.get();
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
	//SharedPtr会管理释放对象的资源
};

对于weak_ptr的模拟实现实际上很简单，只需要接收shared_ptr的对象，将shared_ptr中管理的资源交给weak_ptr一同管理，不同的是weak_ptr实际只是起到一个传递指针的作用，参与管理资源并没有被shared_ptr中的引用计数记录。