当前位置： 首页 > article >正文

【C++11】智能指针

article 2024/12/29 2:21:52

在这里插入图片描述

🔥个人主页： Forcible Bug Maker
🔥专栏： C++

目录

  • 🌈前言
  • 🔥抛异常导致的内存泄露
  • 🔥智能指针的原理
  • 🔥库中智能指针
    • std::auto_ptr
    • std::unique_ptr
    • std::shared_ptr
    • std::weak_ptr
    • 定制删除器
  • 🌈结语

🌈前言

本篇博客主要内容：C++11中的智能指针的使用；并对几种常见智能指针进行简单自实现。

上篇博客主要讲到了异常的使用，也稍微提到一些规定，如：不要再new后delete前抛出异常。稍后将会为大家详解其中缘由，并给出解决方式——智能指针。

🔥抛异常导致的内存泄露

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw "除0错误！";
	return a / b;
}

void func()
{
	int* ptr1 = new int(1);
	int* ptr2 = new int(2);

	cout << div() << endl;

	delete ptr1;
	delete ptr2;
}
int main()
{
	int i = 2;
	while (i--) {
		try
		{
			func();
		}
		catch (const char* errs)
		{
			cout << errs << endl;
		}
		catch (...)
		{
			cout << "未知错误" << endl;
		}
	}
	return 0;
}

观察下以上代码的运行结果：
在这里插入图片描述
代码顺利执行，但是在报出除零错误前就已经发生了错误——内存泄露。div函数中抛出异常，由于func中没有将异常捕获，导致跳入主函数中才被捕捉，过程中delete释放空间的语句完全被忽视，从而导致内存泄露。

可能你会想，可以在func函数中提前捕获此异常，并在异常处理中单独释放资源，这样确实可以解决问题，但本案例代码只是个示例，实际中抛出大量异常的情况下，此想法极难实施。

我给出的解决方式是，用一个对象来管理指向某资源的指针，在执行语句跳出某函数体时，管理指针的对象会自动调用析构函数释放指针指向的资源，这种思想也就是本篇主题，智能指针的最基本的逻辑。

🔥智能指针的原理

RAII思想：
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

  • 不需要显示的释放资源
  • 对象所需的资源在其生命周期内始终保持有效
// 一个简单到极致的智能指针
template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr)
		:_ptr(ptr)
	{}

	~SmartPtr()
	{
		delete _ptr;
	}
private:
	T* _ptr;
};

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw "除0错误！";
	return a / b;
}

void func()
{
	SmartPtr<int> sp1(new int(1));
	SmartPtr<int> sp2(new int(2));

	cout << div() << endl;

}

int main()
{
	int i = 2;
	while (i--) {
		try
		{
			func();
		}
		catch (const char* errs)
		{
			cout << errs << endl;
		}
		catch (...)
		{
			cout << "未知错误" << endl;
		}
	}
	return 0;
}

此时再抛出除零异常时，就不会出现内存泄露了，因为再跳出func函数体时，会调用SmartPtr对象的析构函数，同时释放指针指向的资源。

🔥库中智能指针

库中的智能指针统一放在<memory>头文件里。

std::auto_ptr

auto_ptr文档
在C++98版本的库中就提供了auto_ptr的智能指针。下面演示的auto_ptr的使用及问题。
auto_ptr的实现原理：权限转移，当一个智能指针对象（auto_ptr类型）赋值给另一个智能指针对象（auto_ptr类型）时，赋值的一方悬空，资源访问权限转移给被复制的对象。

#include<iostream>
#include<memory>
using namespace std;

int main()
{
	auto_ptr<int> ap1(new int(1));
	auto_ptr<int> ap2;

	cout << *ap1 << endl;

	ap2 = ap1;

	cout << *ap2 << endl;
	cout << *ap1 << endl;
	return 0;
}

在这里插入图片描述
考虑到auto_ptr在实际中容易因为使用不当而出错，所以一般都不会用。

std::unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr文档
unique_ptr的实现原理：简单粗暴的防止发生拷贝行为，下面模拟实现了一份用于理解此过程。

// 原理：简单粗暴--防止拷贝行为
namespace ForcibleBugMaker
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}

		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
			}
		}

		//支持像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}

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

		unique_ptr(const unique_ptr<T>& up) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& up) = delete;
	private:
		T* _ptr;
	};
}

std::shared_ptr

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr
shared_ptr文档
shared_ptr的原理：通过引用计数的方式来实现多个shared_ptr之间共享资源。当引用计数为0时（也就是最后一个维护指针的对象销毁时），自动释放资源。

// 简化版shared_ptr
// 引用计数支持多个拷贝管理同一个资源，最后一个析构对象释放资源
namespace ForcibleBugMaker
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pcount(new int(1))
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(_pcount);
		}
		shared_ptr<T>& operator(const shared_ptr<T>& sp)
		{
			if (_ptr == sp._ptr)
				return *this;
			_release();
			_ptr = sp._ptr;
			_pcount = sp._pcount;
			++(*_pcount);
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T operator->()
		{
			return _ptr;
		}
		T* get() const
		{
			return _ptr;
		}
		int use_count()
		{
			return *_pcount;
		}
		~shared_ptr()
		{
			_release();
		}
	private:
		void _release()
		{
			if (_ptr && --(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;
				_ptr = _pcount = nullptr;
			}
		}
	private:
		T* _ptr;
		int* _pcount;
	};
}

shared_ptr的缺陷——循环引用导致内存泄露
如果使用shared_ptr用来维护双向链表的一个个结点，那么便会造成循环引用，见如下案例：

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	// 到目前为止无问题
	// 以下两句直接导致循环引用
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

在这里插入图片描述
从运行结果可以看出，并未调用析构函数，所以发生了内存泄露。

  1. 当node1和node2两个智能指针对象分别指向两个结点，引用计数变成1，不需要我们手动delete。
  2. node1的_next指向node2，node2的_prev指向node1时，两边智能指针对象的引用计数均变成2。
  3. 这时候循环引用问题便出现了，当退出当前函数栈帧开始析构时：只有_next析构，node2才能释放；只有_prev析构，node1才能析构。
  4. 但是_next属于node的成员，node1释放， _next才会析构；而node1由_prev管理，_prev属于node2的成员。
  5. 结果是，node1释放，需要node2先释放；node2释放，又需要node1先释放，最终谁也释放不了，这就叫循环引用。

在这里插入图片描述

解决方案：引用计数的场景下，把节点中_prev和_next的智能指针类型改成weak_ptr即可。

std::weak_ptr

shared_ptr循环引用问题的解决方案，同时weak_ptr不支持RAII，不能单独管理资源。
weak_ptr文档
weak_ptr原理：weak_ptr可以作为循环引用解决方案的原因是，使用weak_ptr智能指针，不会增加shared_ptr的引用计数。

// 简化版本的weak_ptr实现
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 _data;
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode() { cout << "~ListNode()" << endl; }
};
int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

在这里插入图片描述
循环引用的问题便解决了。

定制删除器

如果不是new出来的对象如何通过智能指针管理呢？其实unique_ptr和shared_ptr分别提供了一种解决方式。

// 仿函数的删除器
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};
template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

class A
{
public:
	int _a;
};

int main()
{
	FreeFunc<int> freeFunc;
	shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	shared_ptr<int> sp2(new int[10], deleteArrayFunc);
	shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });
	shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p) {fclose(p); });

	unique_ptr<int, FreeFunc<int>> up1((int*)malloc(4));
	unique_ptr<int, DeleteArrayFunc<int>> up2(new int[10]);
	return 0;
}

在这里插入图片描述
是的，如你所见，shared_ptr和unique_ptr应用删除器的方式有很大不同。shared_ptr需要将删除器对象传入参数列表当中；而unique_ptr需要将删除器的类型传入参数模板中。不过两者都提供了传入删除器的方式，可以更好的控制不同类型的资源。

🌈结语

C++11 引入的智能指针（std::unique_ptr、std::shared_ptr 和 std::weak_ptr）是自动内存管理的一个重要里程碑，它们通过RAII（Resource Acquisition Is Initialization）原则帮助开发者避免内存泄漏和其他资源管理问题。总的来说，C++11 智能指针通过提供自动内存管理和增强的安全性，极大地改善了C++程序的稳定性和可维护性。学好智能指针，也更有利于我们对C++的理解。


http://www.kler.cn/a/305965.html

相关文章：

  • WebRTC 环境搭建
  • 如何快速找到合适的科学问题
  • MacOS安装Xcode（非App Store）
  • 策略模式以及优化
  • 如何检查交叉编译器gcc工具链里是否有某个库(以zlib库和libpng库为例)
  • 【java面向对象编程】第九弹----抽象类、接口、内部类
  • AMD FSR 4已秘密开发1年 支持AI帧生成
  • opencv之图像梯度
  • Android实现关机和重启功能
  • Linux开发讲课43---/proc/net/dev文件内容详解
  • springboot-创建连接池
  • 【第36章】Spring Cloud之Seata分布式事务
  • GNU力量注入Windows：打造高效跨平台开发新纪元
  • linux上用yolov8训练自己的数据集（pycharm远程连接服务器）
  • C#中的Date Time类
  • java构造器
  • Mysql 面试题总结
  • 51. 数组中的逆序对
  • 使用 Spring Boot + Vue + ElementUI 构建简易评分系统
  • 信息安全工程师（3）TCP/IP协议簇
  • 软件测试工程师面试整理-测试生命周期
  • gingivitis
  • CSS3中的@media查询
  • HTML5超酷炫的水果蔬菜在线商城网站源码系列模板1
  • 如何调试本地npm package
  • MySQL之表的约束