C++智能指针

最新推荐文章于 2024-09-16 17:46:36 发布

23级二本计科

最新推荐文章于 2024-09-16 17:46:36 发布

阅读量968

点赞数 9

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/wws7920/article/details/141023531

版权

一.为什么需要智能指针

在抛异常过程中我们可能会内存泄漏的问题。


double Division(int a, int b)
{
	// 当b == 0时抛出异常
	if (b == 0)
	{
		throw "Division by zero condition!";
	}
	return (double)a / (double)b;
}
void Func()
{
	// 这里可以看到如果发生除0错误抛出异常，另外下面的array没有得到释放。
	// 所以这里捕获异常后并不处理异常，异常还是交给外面处理，这里捕获了再
	// 重新抛出去。
	int* array = new int[10];
	try {
		int len, time;
		cin >> len >> time;
		cout << Division(len, time) << endl;
	}
	//先释放array再抛出异常
	catch (...)
	{
		cout << "delete []" << array << endl;
		delete[] array;
		throw;
	}
	// ...
	cout << "delete []" << array << endl;
	delete[] array;
}
int main()
{
	try
	{
		Func();
	}
	catch (const char* errmsg)
	{
		cout << errmsg << endl;
	}
	return 0;
}

我们是先手动释放自己申请的资源，再重写抛出异常。虽然能解决，但过于麻烦。

所以我们引出了智能指针，让申请的资源在生命周期结束后，自动释放。

二.auto_ptr 不建议使用

//头文件
#include<memory>
using namespace std;

int main()
{
	//auto_ptr<类型> 变量名（new）
	auto_ptr<int> a(new int(5));
	auto_ptr<int> b;

}

auto_ptr虽然确实能让申请的资源在生命周期结束时释放，但有不足之处。况且我们有更好用的智能指针。

1.赋值/拷贝实现只是转移的资源的所有权

b=a 进行赋值后a的资源转移给了b，再对a访问就会访问空.

2.不支持对数组类型的管理

三.unique_ptr 不支持拷贝/赋值

如果不进行拷贝/赋值建议使用unique_ptr

当我们申请多个对象时，该怎么做呢？

int main()
{
	unique_ptr<Date> p1(new Date(2, 2, 2));
	unique_ptr<Date> p2(new Date[5]);
}

可以看到这种写法是不对的，根本原因是我们没有传删除器，导致delete和new[]进行匹配。

对于new[] 我们可以自己传删除器，也可以走模板特化。

四.shared_ptr 可拷贝/赋值

和unique_ptr不同的是，删除器不能传给模板参数，要传给对象的形参。

make_shared

这两种初始化方式有什么不同吗？

从功能上没有什么区别，但用make_shared<T>（）能缓解内存碎片化。

shared_ptr 除了为对象申请一块空间外，还会额外申请空间来记录有多少个指针指向这块空间。

make_shared 会把这两部分空间一块申请，让申请的空间集中在一块，而new要分别申请两次，会造成内存碎片化。

shared_ptr原理

智能指针原理：通过类来封装原始指针，再创建该类的对象，等到出了作用域，生命周期结束，对象就会自动调用析构函数释放资源。

shared_ptr就是在这基础上考虑怎么实现指针的复制。

*p1赋值/拷贝*p2会让两个指针同时指向同一块空间，*p1析构了，*p2还在那么该空间就不能释放，只有指向该空间的所有指针都消失才能析构。

所有我们专门申请一块空间来记录该空间有多少个指针指向它，每多一个指向它的count就++，减少就--，count==0时就释放。

那么count类型是什么？
int 说明每一个智能指针都有独立的count 同时指向一块空间的指针要有同一个count才行

static int 设为静态变量的话，它是属于整个类的，所有指针都有同一个count，对于指向不同空间的指针肯定是不行的。

int* 才可以。指向相同空间的指针，就同时指向该空间对应的计数空间。

shared_ptr简单实现

#include<functional>
namespace wws
{
	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)
		{};
		//拷贝
		 shared_ptr(const shared_ptr<T>& s)
		{
			_ptr = s._ptr;
			_pcount = s._pcount;
			*_pcount++;
		}
		//删除指向该空间的一个指针
		void release()
		{
			//为0释放空间
			if (--*(_pcount) == 0)
			{
				//delete _ptr;
				_del(_ptr);
				delete _pcount;
				_ptr = _pcount=nullptr;
			}
		}
		//赋值 可能是已存在对象赋值给已存在对象 p1=p2
		//1.p1已经指向一块空间，先对p1指向的计数空间-- 在指向p2指向的空间
		//2.给自己赋值，无意义的情况 p1=p1 p1=p2但p1p2指向同一块空间
		shared_ptr<T>& operator=(const shared_ptr<T>& s)
		{
			//排除自己给自己赋值
			if (_ptr != s._ptr)
			{
				//先删除再指向别的空间
				release();
				_ptr = s._ptr;
				_pcount = s._pcount;
				*_pcount++;
			}
			return *this;
		}
		~shared_ptr()
		{
			release();
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
		//D _del D不是传给模板的不能用
		//D 是一个可调用对象（函数，函数指针，仿函数，lambda） 可以用包装器来包装它
		function<void(T* ptr)> _del = [](T* ptr){delete ptr; };
		//给缺省值是为了不传删除器的情况
	};
}