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

EterNity_TiMe_2024-09-07 13:19

📝个人主页🌹：Eternity._

⏩收录专栏⏪：C++ " 登神长阶 "

🤡往期回顾🤡：C++异常处理机制

🌹🌹期待您的关注 🌹🌹


❀C++智能指针

前言：在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++)：

cpp 复制代码 
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类：

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

🌄智能指针的原理

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

c 复制代码 
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++)：

cpp 复制代码 
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存在较严重的问题，很多公司明确要求不能使用

c 复制代码 
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++)：

cpp 复制代码 
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;
};
cpp 复制代码 
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++)：

cpp 复制代码 
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的时候一定要注意，不能循环引用

cpp 复制代码 
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++)：

cpp 复制代码 
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;
};

循环引用解决方案：

cpp 复制代码 
struct ListNode
{
	int val;
	pxt::weak_ptr<ListNode> prev;
	pxt::weak_ptr<ListNode> next;

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

删除器

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

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

cpp 复制代码 
template<class T>
struct DelArray
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};

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

cpp 复制代码 
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; }; 
	// 提供一个缺省参数，确保在没有提供删除器的情况下能正常使用
};
cpp 复制代码 
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. 内存泄漏

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

🍁内存泄漏的危害

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

内存泄漏的原因：

cpp 复制代码 
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++浩瀚知识海洋中的一朵浪花，还有更多精彩的内容等待我们去发掘和探索，不断提升自己的编程能力，在编程的世界里创造属于自己的辉煌


希望本文能够为你提供有益的参考和启示，让我们一起在编程的道路上不断前行！
谢谢大家支持本篇到这里就结束了，祝大家天天开心！

相关推荐
豆浩宇7 分钟前
Halcon OCR检测 免训练版
c++·人工智能·opencv·算法·计算机视觉·ocr
Hello-Mr.Wang11 分钟前
vue3中开发引导页的方法
开发语言·前端·javascript
救救孩子把14 分钟前
Java基础之IO流
java·开发语言
WG_1715 分钟前
C++多态
开发语言·c++·面试
宇卿.22 分钟前
Java键盘输入语句
java·开发语言
Amo Xiang32 分钟前
2024 Python3.10 系统入门+进阶（十五）：文件及目录操作
开发语言·python
friklogff1 小时前
【C#生态园】提升C#开发效率：深入了解自然语言处理库与工具
开发语言·c#·区块链
潮汐退涨月冷风霜1 小时前
机器学习之非监督学习（四）K-means 聚类算法
学习·算法·机器学习
GoppViper1 小时前
golang学习笔记29——golang 中如何将 GitHub 最新提交的版本设置为 v1.0.0
笔记·git·后端·学习·golang·github·源代码管理
羊小猪~~1 小时前
深度学习基础案例5--VGG16人脸识别(体验学习的痛苦与乐趣)
人工智能·python·深度学习·学习·算法·机器学习·cnn
热门推荐
01RAG 实践- Ollama+RagFlow 部署本地知识库02组基轨迹建模 GBTM的介绍与实现（Stata 或 R）032024年高教社杯数学建模国赛C题超详细解题思路分析04Coze扣子平台完整体验和实践（附国内和国际版对比）05苍穹外卖面试总结06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提07yolov8实战第五天——yolov8+ffmpg实时视频流检测并进行实时推流——（推流，保姆教学）08CCF-CSP认证考试 202406-3 文本分词 100分题解09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10浏览器插件——ModHeader 的分享和学习