【C++高阶】深入理解C++智能指针：掌握RAII与内存安全的利器

Eternity._

发布于 2024-09-08 13:06:07

1400

发布于 2024-09-08 13:06:07

文章被收录于专栏：登神长阶

前言：在C++的浩瀚宇宙中，内存管理一直是程序员们必须面对的重要课题。从早期的手动分配与释放，到现代C++标准库中引入的智能指针，每一次进步都标志着C++在提升开发效率、减少错误风险方面的巨大飞跃。智能指针，作为C++11及后续版本中不可或缺的一部分，不仅极大地简化了资源管理，还通过其独特的机制有效防止了内存泄漏和野指针的出现，成为了现代C++编程中不可或缺的工具

本文旨在带领读者深入探索C++智能指针的奥秘，从std::unique_ptr到std::shared_ptr，再到较为特殊的std::weak_ptr，我们将一一剖析这些智能指针的设计理念、使用方法、以及它们背后的原理。通过实例演示和理论解析相结合的方式，帮助读者不仅学会如何正确使用智能指针，更能理解其背后的RAII（Resource Acquisition Is Initialization）资源管理思想，从而在C++编程中更加游刃有余地管理资源

我们将一起踏上探索C++智能指针的奇妙旅程，共同见证它在提升代码质量、保障程序安全方面的巨大力量，让我们携手前行，在C++的编程世界中，共同书写属于自己的辉煌篇章！

📒1. 智能指针的引入

内存方面情景代码示例 (C++)：

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
	{
		throw invalid_argument("除0错误");
	}
	return a / b;
}
void Func()
{
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;

	delete p1;
	cout << "delete p1" << p1 << endl;

	delete p2;
	cout << "delete p2" << p2 << endl;

}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

当我们正常输入时：程序正常

当我们程序异常终止时：申请的空间并不会被释放

这样就会造成内存泄漏，因此为了能够限制内存泄漏，就有了智能指针

📚2. 智能指针的使用及原理

智能指针（Smart Pointers）是现代C++编程中非常重要的一种内存管理技术，旨在解决原始指针使用过程中的内存泄漏、野指针等问题。智能指针是模板类，能够像普通指针一样被操作，但它能在适当的时候自动释放所管理的对象，从而保证资源的正确释放

⛰️RAII

RAII是一种在C++（以及C++风格的其他编程语言中）常用的资源管理技术。

它的基本思想是：资源的获取在对象的构造时完成，而资源的释放（Release）则在对象的生命周期结束时自动执行，通常是在对象的析构函数中完成。我们实际上把管理一份资源的责任托管给了一个对象，这种方式有助于管理如动态分配的内存、文件句柄、网络连接、互斥锁等需要显式释放的资源

RAII的好处

自动资源管理： RAII通过对象的生命周期来管理资源，一旦对象被销毁，其所管理的资源也会被自动释放，无需手动调用释放函数
异常安全： 由于资源的释放是在对象的析构函数中进行的，而析构函数会在对象生命周期结束时自动调用，即使发生异常也是如此，因此可以保证资源的正确释放，避免了资源泄露
简化代码： 使用RAII可以使得资源管理相关的代码更加简洁，减少了因忘记释放资源而导致的错误

使用RAII思想设计的SmartPtr类：

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << "delete -> " << _ptr << endl;
		delete _ptr;
	}
private:
	T* _ptr;
};

🌄智能指针的原理

但是刚刚的SmartPtr还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：AutoPtr模板类中还得需要将* 、->重载下，才可让其像指针一样去使用

template<class T>
	class SmartPtr
	{
	public:
		SmartPtr(T* ptr)
			:_ptr(ptr)
		{}

		~SmartPtr()
		{
			cout << "delete -> " << _ptr << endl;
			delete _ptr;
		}

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

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

	private:
		T* _ptr;
	};

int main()
{
	SmartPtr<int> sp1(new int);
	*sp1 = 10
	cout<<*sp1<<endl;
	return 0;
}

智能指针的原理：

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

🌞std::auto_ptr

C++98版本的库中就提供了auto_ptr的智能指针

std::auto_ptr文档

auto_ptr的实现原理：管理权转移的思想，我们来简单模拟实现一下它，来了解它的原理

auto_ptr模拟实现 (C++)：

template<class T>
class auto_ptr
{
public:
	auto_ptr(T* ptr)
		:_ptr(ptr)
	{}
	
	auto_ptr(auto_ptr<T>& sp)
		:_ptr(sp._ptr)
	{
		// 控制权转移
		sp._ptr = nullptr;
	}

	auto_ptr<T>& operator=(auto_ptr<T>& ap)
	{
		// 检查是否给自己赋值
		if (this != &ap)
		{
			// 释放当前对象中资源
			if (_ptr)
			{
				delete _ptr;
			}
				
			// 转移ap中资源到当前对象中
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}

		return *this;
	}
	
	~auto_ptr()
	{
		if (_ptr)
		{
			cout << "delete -> " << _ptr << endl;
			delete _ptr;
			_ptr = nullptr;
		}
	}

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

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

private:
	T* _ptr;
};

但是由于auto_ptr存在较严重的问题，很多公司明确要求不能使用

void Test_auto_ptr()
{
	pxt::auto_ptr<int> ap1(new int);
	pxt::auto_ptr<int> ap2 = ap1;

	// 管理权转移，导致ap1对象悬空
	/*(*ap1)++;
	(*ap2)++;*/
}

🌙std::unique_ptr

C++11中开始提供更靠谱的unique_ptr

std::unique_ptr文档文档

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理
C++11出来之前， boost搞出了更好用的scoped_ptr/shared_ptr/weak_ptr 之后C++11借鉴了boost库中智能指针， C++11搞出unique_ptr/shared_ptr/weak_ptr

unique_ptr模拟实现 (C++)：

template<class T>
class unique_ptr
{
public:
	unique_ptr(T* ptr)
		:_ptr(ptr)
	{}

	~unique_ptr()
	{
		if (_ptr)
		{
			cout << "delete -> " << _ptr << endl;
			delete _ptr;
			_ptr = nullptr;
		}
	}

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

	T* operator->()
	{
		return _ptr;
	}
	// 防拷贝
	unique_ptr(auto_ptr<T>& sp) = delete;
	unique_ptr<T>& operator=(unique_ptr<T>& up) = delete;

private:
	T* _ptr;
};

void Test_unique_ptr()
{
	pxt::unique_ptr<int> up1(new int);
	//pxt::unique_ptr<int> up2(up1);
}

⭐std::shared_ptr与std::weak_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

std::shared_ptr文档文档

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

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

shared_ptr模拟实现 (C++)：

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

	shared_ptr(shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		, _pcount(sp._pcount)
	{
		++(*_pcount);
	}
	
	// 获取数量
	int use_count() const
	{
		return *_pcount;
	}
	
	// 获取指针
	T* get() const
	{
		return _ptr;
	}

	shared_ptr<T>& operator=(shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr)
		{
			release();

			_ptr = sp._ptr;
			_pcount = sp._pcount;
			
			++(*_pcount);
		}
		return *this;
	}

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

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

private:
	T* _ptr;
	int* _pcount;
};

强如shared_ptr也会存在一定的问题需要我们解决，我们在使用shared_ptr的时候一定要注意，不能循环引用

struct ListNode
{
	int val;
	pxt::shared_ptr<ListNode> prev;
	pxt::shared_ptr<ListNode> next;

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

void Test_shared_ptr()
{
	pxt::shared_ptr<ListNode> n1(new ListNode);
	pxt::shared_ptr<ListNode> n2(new ListNode);
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	// 循环引用
	n1->next = n2;
	n2->prev = n1;
}

解决方案： 在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了

原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数

weak_ptr模拟实现 (C++)：

template<class T>
class weak_ptr
{
public:
	weak_ptr()
		:_ptr(nullptr)
	{}

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

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

循环引用解决方案：

struct ListNode
{
	int val;
	pxt::weak_ptr<ListNode> prev;
	pxt::weak_ptr<ListNode> next;

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

删除器

shared_ptr设计了一个删除器来解决一些不是new出来的对象的智能指针管理

仿函数的删除器 (C++)：

template<class T>
struct DelArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};

在增加删除器后，shared_ptr的参数变多了，因此我们还要修改一下shared_ptr的模拟实现

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

	template<class D>
	shared_ptr(T* ptr ,D del)
		: _ptr(ptr)
		, _pcount(new int(1))
		,_del(del)
	{}

	//function<void(T*)> _del;

	void release()
	{
		if (--(*_pcount) == 0)
		{
			//cout << "delete -> " << _ptr << endl;
			//delete _ptr;
			_del(_ptr);

			delete _pcount;
		}
	}
	// 其他函数.......
private:
	T* _ptr;
	int* _pcount;
	// 提供一个包装器来确定_del的类型
	function<void(T*)> _del = [](T* ptr) {delete[] ptr; }; 
	// 提供一个缺省参数，确保在没有提供删除器的情况下能正常使用
};

void Test_shared_ptr2()
{
	// 定制删除器
	pxt::shared_ptr<ListNode> sp1(new ListNode[10], DelArray<ListNode>());
	
	// 也可以通过我们之前学习的Lambda来实现
	pxt::shared_ptr<ListNode> sp2(new ListNode[10], [](ListNode* ptr) {delete[] ptr; });
	pxt::shared_ptr<ListNode> sp3(new ListNode[10]);

📜3. 内存泄漏

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

🍁内存泄漏的危害

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

内存泄漏的原因：

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

🍂内存泄漏的分类与检测 (了解)

C/C++程序中一般有两种方面的内存泄漏：

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

检测内存泄漏： 在linux下内存泄漏检测：linux下几款内存泄漏检测工具

在windows下使用第三方工具：VLD工具说明

其他工具：内存泄漏工具比较

🌸如何避免内存泄漏

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

内存泄漏常见解决方案分为两种：

事前预防型。如智能指针等
事后查错型。如泄漏检测工具

📝4. C++11和boost中智能指针的关系

C++ 98 中产生了第一个智能指针auto_ptr
C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr
C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版
C++ 11，引入了unique_ptr和shared_ptr和weak_ptr

在C++ 11中，需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的

📖5. 总结

随着我们对C++智能指针的深入探索，不难发现，这一特性不仅是C++标准库中的一颗璀璨明珠，更是现代C++编程中不可或缺的基石。通过智能指针，我们不仅能够享受到自动内存管理的便利，减少手动管理资源所带来的繁琐和错误风险，还能深刻理解RAII（Resource Acquisition Is Initialization）资源管理模式的精髓，从而在编程实践中更加高效、安全地管理资源

我们共同见证了std::unique_ptr、std::shared_ptr以及std::weak_ptr等智能指针的神奇之处，从它们的设计理念到实际应用，从基本用法到高级技巧，我们一步步深入，逐渐揭开了智能指针的神秘面纱。相信通过本文的学习，你已经对C++智能指针有了更为全面和深入的理解，也能够在自己的编程实践中灵活运用这一强大工具

但是我还是想说，学习之路永无止境。智能指针只是C++浩瀚知识海洋中的一朵浪花，还有更多精彩的内容等待我们去发掘和探索，不断提升自己的编程能力，在编程的世界里创造属于自己的辉煌

本文参与腾讯云自媒体同步曝光计划，分享自作者个人站点/博客。

原始发表：2024-09-07，如有侵权请联系 cloudcommunity@tencent.com 删除

c++