我们在上篇文章中（异常处理详解）提到了 RAII 。那么本篇文章会对此进行详解。重点是智能指针的详解。其中会讲解到 RAII 思想、auto_ptr、unique_ptr、shared_ptr、weak_ptr、循环引用问题。希望本篇文章会对你有所帮助。

文章目录

一、为什么需要智能指针

二、智能指针的使用及原理

2、1 RAII 解释

2、2 什么是智能指针

2、3 auto_ptr

2、3、1 auto_ptr 的使用

2、3、2 auto_ptr 的模拟实现

2、4 unique_ptr

2、5 shared_ptr

三、循环引用问题及解决

3、1 weak_ptr

四、内存泄漏问题

4、1 什么是内存泄漏

4、2 内存泄漏分类

4、3 如何规避内存泄漏

---

🙋‍♂️ 作者：@Ggggggtm 🙋‍♂️

👀 专栏：C++ 👀

💥 标题：智能指针 💥

❣️  寄语：与其忙着诉苦，不如低头赶路，奋路前行，终将遇到一番好风景 ❣️ 

一、为什么需要智能指针

  我们先看如下一段代码：

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

  上述一段简短的代码，其实隐含了许多问题。这里给出三个问题：1、如果p1这里new 抛异常会如何？2、如果p2这里new 抛异常会如何？3、如果div调用这里又会抛异常会如何？其实都会造成内存泄露。当然，我们上篇文章也讲到，可以选择异常重新抛出进行解决，但是如果 p2 内存申请失败了呢？有人说可以进行异常检查。确实可以处理。但是这仅仅只有两个动态申请指针。如果类似还有p3、p4、p5……就要进行很复杂的分情况处理。

  智能指针就可以很轻松的解决上述的情况。下面我们学习一下智能指针。

二、智能指针的使用及原理

2、1 RAII 解释

  在了解指针指针之前，我们先学习一下RAII。

  RAII，全称Resource Acquisition Is Initialization（资源获取即初始化），是一种在C++中用于管理资源的编程技术。它基于一种简单的原则，即在对象的构造函数中获得资源（例如内存、文件句柄、锁等），并在析构函数中释放这些资源。RAII采用的是C++的对象生命周期管理机制，确保在对象离开作用域时资源的正确释放，无论是通过正常流程离开还是通过异常离开。

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

• 不需要显式地释放资源。
• 采用这种方式，对象所需的资源在其生命期内始终保持有效。

  我们通过一段代码来理解一下：

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}
private:
	T* _ptr;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	ShardPtr<int> sp1(new int);
	ShardPtr<int> sp2(new int);
	cout << div() << endl;
}
int main()
{
	try {
		Func();
	}
	catch (const exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

   上述代码就是把动态申请的资源交给一个类对象处理，我们只需要在该类的析构函数中对该对象进行释放即可。这样做的好处是什么呢？首先，我们不用自己手动去释放动态申请的资源。其次，即使程序出现异常崩溃了，也会将资源释放掉（类对象出了作用域会自动调用析构函数）。上述思想就是所谓了资源获取即初始化。

2、2 什么是智能指针

  传统的指针在使用过程中需要手动分配和释放内存，经常容易出现内存泄漏或者悬挂指针等问题，给程序带来安全隐患。

  智能指针是一种特殊类型的指针，它可以自动管理内存的分配和释放，为程序员提供方便和安全。智能指针通过在对象生命周期结束时自动释放指向的内存空间，减少了内存泄漏的风险。

  我们发现智能指针的概念就是采用了RAII的思想。与上面 SmartPtr 极为相似。但是上述的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可
以通过->去访问所指空间中的内容。代码如下：

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};
struct Date
{
	int _year;
	int _month;
	int _day;
};
int main()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 10;
	cout << *sp1 << endl;

	// 需要注意的是这里应该是sparray.operator->()->_year = 2018;
	// 本来应该是sparray->->_year这里语法上为了可读性，省略了一个->
	SmartPtr<Date> sparray(new Date);
	sparray->_year = 2018;
	sparray->_month = 1;
	sparray->_day = 1;
	return 0;
}

2、3 auto_ptr

  在C++中,auto_ptr是一个早期的智能指针类，用于管理动态分配的对象。它是C++98标准引入的，但已在C++11中基本上被废弃。我们来看看其使用和为什么要别弃用。

2、3、1 auto_ptr 的使用

   我们先看如下代码：

class A
{
public:
	~A()
	{
		cout << "~A()" << endl;
	}
	//private:
	int _a1 = 0;
	int _a2 = 0;
};

int main()
{
	auto_ptr<A> ap1(new A);
	ap1->_a1++;
	ap1->_a2++;

	auto_ptr<A> ap2(ap1);
	ap1->_a1++;
	ap1->_a2++;
	return 0;
}

  运行结果是崩溃了，如下图：

  这是为什么呢？当将一个auto_ptr拷贝给另一个auto_ptr时，将会管理权（资源）转移（这里是指将ap1的资源转移给了ap2）。

  这个看上去好像没有什么问题，但是又好像是一个bug级别的存在。因为一不下心再去使用ap1 时，就会出现内存问题。其实底层实现也是管理权转移的思想。这也是auto_ptr现在基本上被弃用的原因了。auto_ptr 的接口含有很多，这里就不再一一解释。

  我们再看一下其底层实现。

2、3、2 auto_ptr 的模拟实现

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

	template<class T>
	class auto_ptr 
	{
	public:
		auto_ptr(T* ptr = nullptr)
			: _ptr(ptr)
		{}

		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}

		// ap1 = ap2;
		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			if (this != &ap)
			{
				if (_ptr)
				{
					delete _ptr;
				}

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

   注意，赋值并不只是资源转移。赋值是先将原本对象的资源进行释放，在进行资源转移。同时，在模拟实现时也需要注意是否自己和自己进行赋值。

2、4 unique_ptr

  unique_ptr 针对auto_ptr 的不足进行了调整，但是调整的有点暴力。在unique_ptr 中，直接将拷贝构造和拷贝赋值直接禁用了。

  其用法与auto_ptr 基本相似，只不过是尽禁掉了拷贝构造和拷贝赋值。我们再来看一下其底层的简单模拟实现。代码如下：

	template<class T>
	class unique_ptr
	{
	private:
		// 防拷贝 C++98
		// 只声明不实现 
		//unique_ptr(unique_ptr<T>& ap);
		//unique_ptr<T>& operator=(unique_ptr<T>& ap);
	public:
		unique_ptr(T* ptr = nullptr)
			: _ptr(ptr)
		{}

		// 防拷贝 C++11
		unique_ptr(unique_ptr<T>& ap) = delete;
		unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}
		}

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

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

	private:
		T* _ptr;
	};

  unique_ptr与auto_ptr极为相似，就不再过多解释unique_ptr。我们重点是在shared_ptr。

2、5 shared_ptr

  shared_ptr 针对之前的智能指针的问题进行了修改调整。不仅仅支持拷贝，而且也更加安全。其使用我们也不再过多详解，主要看一下其底层实现。

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

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

  那我们怎么来维护这个计数呢？首先，普通的 int 成员是不可以的。因为我们想要的时一个类对象只有一个计数。如果是普通的 int 成员，实例化每个对象都会都一个计数。

  用static 成员可不可以呢？也是不行的！我们看如下代码：

shared_ptr<A> sp1(new A);
shared_ptr<A> sp2(sp1);
shared_ptr<A> sp3(sp1);

shared_ptr<int> sp4(new int);

  如果是 static 成员，那么不同类型的对象也是共享一个计数。显然这样是不正确的。

  采用一个指针可不可以呢？答案是可以的。我们采用指针时，只有在构造时，才进行申请新的指针。当采用拷贝或者赋值时，我们选择将指针进行资源转移，而不是申请新指针。这样就可以很好的控制一个类对象只有一个计数了。下面我们结合模拟实现的代码理解一下：

	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			: _ptr(ptr)
			, _pCount(new int(1))
		{}

		void Release()
		{
			if (--(*_pCount) == 0)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
				delete _pCount;
			}
		}

		~shared_ptr()
		{
			Release();
		}

		// sp1(sp2)
		shared_ptr(const shared_ptr<T>& sp)
			: _ptr(sp._ptr)
			, _pCount(sp._pCount)
		{
			(*_pCount)++;
		}

		// sp1 = sp5
		// sp1 = sp1
		// 20:16继续
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//if (this == &sp)
			if (_ptr == sp._ptr)
			{
				return *this;
			}

			// 减减被赋值对象的计数，如果是最后一个对象，要释放资源
			/*if (--(*_pCount) == 0)
			{
				delete _ptr;
				delete _pCount;
			}*/
			Release();

			// 共管新资源，++计数
			_ptr = sp._ptr;
			_pCount = sp._pCount;

			(*_pCount)++;

			return *this;
		}

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

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

	private:
		T* _ptr;

		// 引用计数
		int* _pCount;
	};
}

三、循环引用问题及解决

  循环引用是指两个或多个对象之间相互引用，形成一个闭环的情况。这种情况下，由于每个对象都持有其他对象的引用计数，导致共享指针无法正确地释放内存。下面我们来看一个实际的例子：

struct Node
{
	int _val;
	std::shared_ptr<Node> _next;
	std::shared_ptr<Node> _prev;

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

void test_shared_ptr2()
{
	std::shared_ptr<Node> n1(new Node);
	std::shared_ptr<Node> n2(new Node);

	n1->_next = n2;
	n2->_prev = n1;
}

  我们可以简单的理解为：双向链表中存储的是智能指针。这时候就引发了循环引用的问题。具体如下图：

  这个时候可以采用weak_ptr 来进行解决。

3、1 weak_ptr

  weak_ptr是与shared_ptr配套使用的弱引用指针。它可以解决循环引用问题，因为它不会增加内存的引用计数。我们先看一下代码：

struct Node
{
	int _val;
	/*std::shared_ptr<Node> _next;
	std::shared_ptr<Node> _prev;*/

	std::weak_ptr<Node> _next;
	std::weak_ptr<Node> _prev;

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

  _next和_prev是weak_ptr时，他不参与资源释放管理，可以访问和修改到资源，但是不增加计数，不存在循环引用的问题了。

四、内存泄漏问题

4、1 什么是内存泄漏

  内存泄漏是指在计算机程序中，通过动态分配内存空间后，无法再次释放这些空间的情况。当程序运行时，如果不再使用某段动态分配的内存空间，但没有显式地将其释放，就会导致内存泄漏的问题。

  内存泄漏可能会导致系统性能下降甚至崩溃。随着时间的推移，内存泄漏会使可用内存越来越少，最终导致程序运行失败或系统崩溃。

  在C++中，内存泄漏通常出现在以下情况下：

1. 动态分配内存后未释放：当使用关键字new或者相关的内存分配函数（例如malloc）在堆上分配了内存空间后，如果没有调用对应的释放函数（例如delete或者free），就会发生内存泄漏。这种情况经常出现在忘记释放内存、程序异常退出等情况下。
2. 在循环中动态分配内存未释放：当在循环中重复动态分配内存空间而未及时释放，在每次循环迭代时都会导致一次内存泄漏。

   for (int i = 0; i < 10; i++) {
       int* ptr = new int; // 动态分配了一个int型的内存空间
       // 未在每次循环结束时释放ptr指向的内存空间，导致每次循环都有内存泄漏
   }

3. 没有正确管理对象的生命周期：当对象在不再使用时没有及时销毁或释放资源，也可能导致内存泄漏。

   class MyClass {
   public:
       MyClass() {
           buffer = new int[1000]; // 在构造函数中动态分配了一个int数组
       }
       ~MyClass() {
           // 在析构函数中应该释放buffer指向的内存空间，但这里没有进行释放
       }
   private:
       int* buffer;
   };
   
   void foo() {
       MyClass obj;
       // 在此处，obj的析构函数没有被调用，导致buffer指向的内存泄漏
   }

4. 循环引用：如果两个或多个对象互相引用，并且没有其他对象引用它们，那么这些对象将无法很好的释放资源，导致内存泄漏。

5. 异常跳转，可能会直接跳转过了释放资源的语句。也会导致内存泄漏。

4、2 内存泄漏分类

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

• 堆内存泄漏(Heap leak)。堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。
• 系统资源泄漏。指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

4、3 如何规避内存泄漏

1. 1工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记着匹配的去释放。ps：这个理想状态。但是如果碰上异常时，就算注意释放了，还是可能会出问题。需要下一条智能指针来管理才有保证。
2. 采用RAII思想或者智能指针来管理资源。
3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
4. 出问题了使用内存泄漏工具检测。ps：不过很多工具都不够靠谱，或者收费昂贵。

  总的来说，内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。