auto_ptr|unique_ptr|shared_ptr|weak_ptr|你都搞明白了吗?

前言

那么这里博主先安利一些干货满满的专栏了!

首先是博主的高质量博客的汇总,这个专栏里面的博客,都是博主最最用心写的一部分,干货满满,希望对大家有帮助。

高质量干货博客汇总https://blog.csdn.net/yu_cblog/category_12379430.html?spm=1001.2014.3001.5482


使用指针如何避免内存泄漏?

  1. 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要智能指针来管理才有保证。

  2. 采用RAII思想或者智能指针来管理资源

  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。

  4. 出问题了使用内存泄漏工具检测。ps:不过很多工具都不够靠谱,或者收费昂贵。

最简单的例子,malloc之后我们就要free,但是如果程序还没有跑到free的地方就因为出问题而终止呢?如果有一个东西,可以像C++到类一样,自己会调用析构,那么我们是不是就不用自己手动去free了?

智能指针RAII思想

RAII(Resource Acquisition Is Initialization)是一种利用对象生命周期来控制程序资源(如内存、文件句 柄、网络连接、互斥量等等)的简单技术。

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

C++STL维护的智能指针有四种:

  • auto_ptr
  • unique_ptr
  • shared_ptr
  • weak_ptr

auto_ptr

auto_ptr的问题:当对象拷贝或者赋值后,前面的对象就悬空了
C++98中设计的auto_ptr问题是非常明显的,所以实际中很多公司明确规定了不能使用auto_ptr

unique_ptr

unique_ptr是C++11标准引入的一种独占所有权的智能指针。它提供了独特的所有权,即一个资源只能被一个unique_ptr拥有。它不能与其他unique_ptr共享或复制。这使得unique_ptr非常轻量和高效。当unique_ptr超出范围或被显式地释放时,它将自动删除其拥有的资源。

shared_ptr

shared_ptr是C++11标准引入的一种共享所有权的智能指针。它可以被多个shared_ptr实例共享,每个实例都持有一个引用计数。引用计数跟踪资源的当前拥有者数量,当最后一个shared_ptr超出范围时,它会自动释放资源。shared_ptr通过引用计数来管理资源,可以在多个地方共享和传递所有权,使其非常适合动态资源管理和循环引用的情况。

weak_ptr

weak_ptr也是C++11标准引入的一种弱引用智能指针。它与shared_ptr一起使用,但不会增加引用计数。weak_ptr只有资源的观察权,没有所有权。weak_ptr用于解决shared_ptr之间的循环引用问题,因为循环引用可能导致资源无法释放。通过检查weak_ptr是否有效,可以判断被观察的资源是否已被释放。

四种智能指针的代码实现

里面注释还提到了很多细节,大家可以都看一下。

#pragma once

#include
using namespace std;

class A
{
public:
	~A()
	{
		cout << "A::~A()" << endl;
	}
	int _a = 0;
	int _b = 0;
};

namespace yufc
{
	template
	class auto_ptr
	{
	private:
		T* _ptr;
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr) {}
		auto_ptr(auto_ptr& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		//ap1 = ap2;
		auto_ptr& operator =(auto_ptr& ap)
		{
			if (this != &ap)
			{
				if (_ptr)
				{
					cout << "Delete:" << _ptr << endl;
					delete _ptr;
				}
				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	};

	//unique_ptr
	template
	class unique_ptr
	{
	private:
		T* _ptr;
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr) {}
		//仿拷贝
		unique_ptr(unique_ptr& ap) = delete;
		unique_ptr& operator=(unique_ptr& ap) = delete;
		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	};

	//shared_ptr
	//我们还是提供一个默认的删除器,不然删啥都得传
	template
	struct DefaultDeleter
	{
		void operator()(T* ptr)
		{
			delete ptr;//默认是delete
		}
	};

	template> //传多一个定制删除器
	class shared_ptr
	{
	protected:
		T* _ptr;
		//static int _count;
		int* _pCount;
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, _pCount(new int(1)) {}
		shared_ptr(shared_ptr& sp)
			:_ptr(sp._ptr)
			, _pCount(sp._pCount)
		{
			(*_pCount)++;
		}
		void release()
		{
			cout << "Delete:" << _ptr << endl;
			D()(_ptr);//用定制删除器释放
			//delete _ptr;
			delete _pCount;
		}
		shared_ptr& operator=(shared_ptr& sp)
		{
			if (_ptr == sp._ptr)
			{
				return *this; 
			}
			if (--(*_pCount) == 0)
			{
				release();
			}

			//共管新资源,++记数
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			(*_pCount)++;
			return *this;
		}
		~shared_ptr()
		{
			if (--(*_pCount) == 0)
			{
				release();
			}
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}

		int use_count()
		{
			return *_pCount;
		}
		T* get() const
		{
			return _ptr;
		}
	};
	//template
	//int shared_ptr::_count = 0;

	//weak_ptr不是一个功能型的智能指针,是辅助型的
	//它的发明是为了解决shared_ptr的循环引用问题
	//STL的实现比我们这个复杂很多,他还处理了很多其他的问题
	//STL的weak_ptr其实保存了引用计数,用于处理过期的问题,具体看杭哥解释
	//STL中的它不增加引用计数,但是它要保存一下
	template
	class weak_ptr
	{
	protected:
		T* _ptr;
	public:
		weak_ptr()
			:_ptr(nullptr) {}
		weak_ptr(const shared_ptr& sp)
			:_ptr(sp._ptr) {}
		weak_ptr(const weak_ptr& wp)
			:_ptr(wp._ptr) {}
		weak_ptr& operator=(const shared_ptr& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		//库里面其实还提供get,提供原生指针
		T* get() const
		{
			return _ptr;
		}
	};
}

//想要实现库里面那一套,还得复杂不少
//其实shared_ptr还涉及到线程安全问题,要加锁的


void test_auto_ptr()
{
	std::auto_ptrap1(new A);
	ap1->_a++;
	std::auto_ptrap2(ap1);
	//ap1->_a++;//err
	//会出现拷贝对象的悬空问题
	//很多公司明确规定不能使用它
	std::auto_ptrap3(new A);
	//注意 -- 这里不是交换 -- 是把ap3的资源转移给ap2,然后把ap2的释放掉,ap3悬空
	ap2 = ap3;
	//ap3->_a++;
}

void test_unique_ptr()
{
	yufc::unique_ptr up1(new A);
	//不准拷贝了
	//std::unique_ptr up2(up1);
	up1->_a++;
	yufc::unique_ptr up2;
	//up2 = up1;//err
}

#if 1
void test_shared_ptr()
{
	yufc::shared_ptr sp1(new A);
	yufc::shared_ptr sp2(sp1);
	yufc::shared_ptr sp3(sp1);
	yufc::shared_ptr sp4(new int(1));
	yufc::shared_ptrsp5(new A);
}
#endif
/**
 * 能否用静态变量来计数?
 * 我们期望是 针对不同空间,我们希望有多个记数,但是如果我们使用了静态变量来记数
 * 所有类型,所有空间的记数都堆在一起了.
 */


//weak_ptr
//循环引用
#if 0
struct Node
{
	int _val;
	yufc::shared_ptr _next;
	yufc::shared_ptr _prev;
	~Node()
	{
		cout << "Node::~Node()" << endl;
	}
};
struct Node2
{
	int _val;
	yufc::weak_ptr _next;
	yufc::weak_ptr _prev;
	~Node2()
	{
		cout << "Node::~Node()" << endl;
	}
};
#endif
#if 0 //stl的weak_ptr测试
void test_weak_ptr()
{
	cout << "before use weak_ptr to construct the Node" << endl;
	std::shared_ptrn1(new Node);
	std::shared_ptrn2(new Node);
	//tips:shared_ptr的构造是加了explicit的 -- 不允许隐式类型转换,所以不能这样写
	//std::shared_ptrn2 = new Node; //err

	//我们看这种情况 -- 此时不能正确释放了 -- 为什么?
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->_next = n2;
	n2->_prev = n1;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	//这里就是循环引用的问题

	//shared_ptr是无法解决这个问题的
	//weak_ptr不是常规的智能指针,没有RAII,不支持直接管理资源
	//weak_ptr就是shared_ptr的小跟班 -- 专门帮忙处理shared_ptr的剩余问题
	//weak_ptr主要用shared_ptr构造 -- 处理循环引用问题

	//当我们把Node里面的_prev和_next改成weak_ptr之后,_prev和_next,就不增加记数
	//它不参与资源释放管理,可以访问和修改资源,不存在循环引用问题
	cout << "after use weak_ptr to construct the Node" << endl;
	std::shared_ptrn11(new Node2);
	std::shared_ptrn21(new Node2);
	cout << n11.use_count() << endl;
	cout << n21.use_count() << endl;
	n11->_next = n21;
	n21->_prev = n11;
	cout << n11.use_count() << endl;
	cout << n21.use_count() << endl;
}



//yufc的weak_ptr测试
void test_weak_ptr2()
{
	cout << " ----- before use weak_ptr to construct the Node ----- " << endl;
	yufc::shared_ptrn1(new Node);
	yufc::shared_ptrn2(new Node);
	//tips:shared_ptr的构造是加了explicit的 -- 不允许隐式类型转换,所以不能这样写
	//std::shared_ptrn2 = new Node; //err

	//我们看这种情况 -- 此时不能正确释放了 -- 为什么?
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	n1->_next = n2;
	n2->_prev = n1;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;
	//这里就是循环引用的问题

	cout << endl << endl;

	//shared_ptr是无法解决这个问题的
	//weak_ptr不是常规的智能指针,没有RAII,不支持直接管理资源
	//weak_ptr就是shared_ptr的小跟班 -- 专门帮忙处理shared_ptr的剩余问题
	//weak_ptr主要用shared_ptr构造 -- 处理循环引用问题

	//当我们把Node里面的_prev和_next改成weak_ptr之后,_prev和_next,就不增加记数
	//它不参与资源释放管理,可以访问和修改资源,不存在循环引用问题
	cout << " ----- after use weak_ptr to construct the Node ----- " << endl;
	yufc::shared_ptrn11(new Node2);
	yufc::shared_ptrn21(new Node2);
	cout << n11.use_count() << endl;
	cout << n21.use_count() << endl;
	n11->_next = n21;
	n21->_prev = n11;
	cout << n11.use_count() << endl;
	cout << n21.use_count() << endl;
}
#endif




//定制删除器
struct Node
{
	int _val;
	std::shared_ptr _next;
	std::shared_ptr _prev;
	~Node()
	{
		cout << "Node::~Node()" << endl;
	}
};
void test5()
{
	std::shared_ptr n1(new Node[5]); //这里报错,因为delete[]没有匹配上
	std::shared_ptr n2(new Node);
	//这其实和new的底层实现是有关系的
	//new[]但是delete没有[] -- 会不会报错?为什么会报错?其实这和平台有关系
	//new Node[5] 这里涉及到Node的构造和析构
	//此时 new Node[5]   -->  5次malloc和5次构造函数
	//如果是delete --> 1次析构函数+free
	//delete[] --> 5次析构函数+free
	//此时如果编译器发现我们的析构函数没写 -- 他会认为这个Node不需要析构 -- 直接free就行
	//他会做优化 -- 因此如果析构函数不写  -- 有时候上面的情况不报错

	//假设Node大小是12,现在new Node[5]
	//在VS下,其实开的不是60字节,而是64字节 -- 4个字节放在头部,用来存个数
	//因为delete[]其实规定不传个数 -- 所以new Node[]的时候会偷偷记录
	//所以调用delete[] 就知道到底要调用多少次析构了
	//所以new []返回来的指针其实比真实malloc出来的地址向后偏移了4个字节
	//delete[]的时候,其实指针就会往前偏移四个字节,先找到个数
	//所以delete[] 其实是free((char*)ptr - 4)这个位置的指针
	//如果直接delete 首先5个Node只析构一个,其次头上的4个字节没人管了

	//所以我们delete的时候要匹配

	//我们用这个智能指针的时候的场景会非常复杂
	std::shared_ptr n3(new Node[6]); 
	std::shared_ptr n4((int*)malloc(sizeof(int) * 12));
	//所以我们需要定制删除器
	//一般是传一个仿函数或匿名参数
}
template
struct DeleteArray
{
	void operator()(T* ptr)
	{
		cout << "delete[] " << ptr << endl;
		delete[] ptr;
	}
};
template
struct Free
{
	void operator()(T* ptr)
	{
		cout << "free() " << ptr << endl;
		free(ptr);
	}
};
void test6()
{
	//这里要看清楚文档 -- shared_ptr的定制删除器是在构造函数里面传的
	//unique_ptr的地址删除器是现在模板参数里面传的
	std::shared_ptr n1(new Node[5], DeleteArray());
	std::shared_ptr n4((int*)malloc(sizeof(int) * 12), Free());
	//这样就不会出问题了
	std::shared_ptr n3(new Node[5], [](Node* ptr) {delete[] ptr; });//这里用匿名函数也是很好用的
	std::shared_ptr n2((int*)malloc(sizeof(int) * 12), [](int* ptr) {free(ptr); });
	//还可以这么玩
	std::shared_ptr n5(fopen("test.txt", "w"), [](FILE* ptr) {fclose(ptr); });


	//unique_ptr不能用匿名函数了,因为要在模板参数里面传对象
	std::unique_ptr>up(new Node[5]);
}
void test7()
{
	//测试我们自己定义的shared_ptr的删除器
	yufc::shared_ptr>up(new Node[5]);
}



//如果我们要像库里面一样,可以从构造函数传,我们目前实现的架构是做不到的
//因为STL里面的计数器其实是封装成了一个类的
//我们传定制删除器的时候其实还往下传了一层
//现在我们如果要通过构造函数传,这个删除器就只能在构造函数里面用了,外面用不了。
//所以我们写一个从模板参数里面传的

//定制删除器在开始里面很少
//不过平时使用还是地用到的

你可能感兴趣的:(C++深度剖析,STL源码剖析,算法)