您现在的位置是：首页 >技术杂谈 >【关于C++中----智能指针】网站首页技术杂谈

【关于C++中----智能指针】

Undefined__yu 2023-05-08 22:30:03
简介【关于C++中----智能指针】

文章目录

一、概念引入

在我们日常写代码过程中，尤其是在一些大型的项目中，往往会使用抛异常和捕获异常的方式处理一些错误。但是，当一段程序中嵌套了大量的try catch之后，代码的可读性将会大大降低。或者，有一些极有可能出现内存泄漏的代码，就更让人难办了。例如：

int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	// 1、如果p1这里new 抛异常会如何？
	// 2、如果p2这里new 抛异常会如何？
	// 3、如果div调用这里又会抛异常会如何？
	int* p1 = new int;
	int* p2 = new int;
	cout << div() << endl;
	delete p1;
	delete p2;
}
int main()
{
	try
	{
		Func();
	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

所以，就有了一系列的智能指针，来帮我们避免这些问题。

二、内存泄漏

2.1 内存泄漏概念及其危害

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

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

下面是一个简单的内存泄漏场景：

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

2.2 内存泄漏分类

C/C++程序中一般我们关心两种方面的内存泄漏：

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

2.3 避免内存泄漏

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

总结一下:
内存泄漏非常常见，解决方案分为两种：1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。

三、智能指针的原理

3.1 RAII

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

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

  • 不需要显式地释放资源。
  • 采用这种方式，对象所需的资源在其生命期内始终保持有效。

举个例子：

// 使用RAII思想设计的SmartPtr类
template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
			cout << "释放资源成功!" << endl;
		}
	}

private:
	T* _ptr;
};
int div()
{
	int a, b;
	cin >> a >> b;
	if (b == 0)
		throw invalid_argument("除0错误");
	return a / b;
}
void Func()
{
	SmartPtr<int> sp1(new int);
	SmartPtr<int> sp2(new int);
	cout << div() << endl;
}

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

在这里插入图片描述

3.2 像指针一样

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

如下：

class SmartPtr 
{
public:
	//RAII
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
			delete _ptr;
	}
	//像指针一样
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};

总结一下智能指针的原理：

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

四、三类智能指针

4.1 auto_ptr

智能指针绝不仅仅像上面的代码这样简单，因为上面的这段代码还有很多问题没有处理，如下：

在这里插入图片描述
可以看到，由于没有实现拷贝构造，编译器自动生成的拷贝构造只是浅拷贝，导致同一块空间被释放了两次，使得程序崩溃。

所以，就有了一些个智能指针，下面来一一介绍（其实智能指针也没有很好用）。

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

namespace sny
{
	template<class T>
	class auto_ptr
	{
	public:
		//RAII
		auto_ptr(T* ptr = nullptr)
			: _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 = NULL;
			}
			return *this;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};
}

但是，它有一个很严重的问题。它会导致对象悬空的问题，也就是拷贝之后，其中一个对象的资源已经被转移了，当再次对该对象做解引用系列的操作时就会崩溃。

在这里插入图片描述

所以，auto_ptr是一个很失败的设计，大多数公司明令禁止使用它，大家也尽量不要用！

4.2 unique_ptr

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份UniquePtr来了解它的原理

namespace sny
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr<T>&sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&sp) = delete;
	private:
		T* _ptr;
	};
}

可以看到，在代码中，已经禁止了任何的拷贝操作。
在这里插入图片描述

4.3 shared_ptr

上述的两种智能指针都是不支持拷贝构造的。为了支持拷贝，C++又出了一个叫做shared_ptr的智能指针。

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

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

下面是其原理的一个简易的模型：

namespace sny
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
		{}
		~shared_ptr()
		{
			if (--(*_pcount) == 0)
			{
				delete _ptr;
				delete _pcount;
				cout << "delete: " << _ptr << endl;
			}
		}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			++(*_pcount);
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pcount;
	};
}

在这里插入图片描述
可见，如果有拷贝的发生，引用计数就会加一。而当定义一个新的对象时，则不会和已经发生拷贝的对象中的引用计数有任何关系。

这里再重点说一下operator=这个操作，要先将当前对象管理的资源对应计数-1，为0时需要释放，然后再传入对象一起管理资源，将该资源对应的计数+1，如下：

void Release()
{
	if (--(*_pcount) == 0)
	{
		delete _pcount;
		delete _ptr;
	}
}
shared_ptr<T>& opreator = (const shared_ptr<T>&sp)
{
	if (_ptr != sp._ptr)
	{
		Release();
		_pcount = sp._pcount;
		_ptr = sp._ptr;
		++(*_pcount);
	}
	return *this;
}

但是，shared_ptr存在多线程的安全问题。当在多个线程中，分别对对象不停地拷贝和析构时，就容易出现引用计数计算出错的问题。如下：

int use_count()
{
	return *_pcount;
}
void test_shared_ptr()
{
	int n = 10000;
	shared_ptr<int> sp1(new int(1));
	thread t1([&]()
		{
			for (int i = 0; i < n; i++)
			{//拷贝时对引用计数++，出了作用域，对象销毁，又要对引用计数--
				shared_ptr<int> sp2(sp1);
			}
		});
	thread t2([&]()
		{
			for (int i = 0; i < n; i++)
			{
				shared_ptr<int> sp3(sp1);
			}
		});
	t1.join();
	t2.join();

	cout << sp1.use_count() << endl;
}

在这里插入图片描述
可以看到，最后sp1的引用计数本该是1，最后差距却如此之大。

为了避免线程安全问题，可以在每一次对引用计数操作之前加锁，操作结束之后再解锁，如下：

shared_ptr(T* ptr)
	:_ptr(ptr)
	, _pcount(new int(1))
	, _pmtx(new mutex)
{}

// 释放资源
~shared_ptr()
{
	Release();
}

shared_ptr(const shared_ptr<T>& sp)
	:_ptr(sp._ptr)
	, _pcount(sp._pcount)
	,_pmtx(sp._pmtx)
{
	_pmtx->lock();
	++(*_pcount);
	_pmtx->unlock();
}

void Release()
{
	bool flag = false;
	_pmtx->lock();
	if (--(*_pcount) == 0)
	{
		delete _pcount;
		delete _ptr;
		flag = true;
	}
	_pmtx->unlock();
	if(flag == true)
		delete _pmtx;
}

// sp1 = sp1;
// sp1 = sp2;
shared_ptr<T>& operator=(const shared_ptr<T>& sp)
{
	if (_ptr != sp._ptr)
	{
		Release();

		_pcount = sp._pcount;
		_ptr = sp._ptr;
		_pmtx->lock();
		++(*_pcount);
		_pmtx->unlock();
	}

	return *this;
}

但是，加锁之后，shared_ptr的线程安全也仅仅限于引用计数的安全，并不能保证资源的安全。

对于这个问题，可以再加一把锁，在访问资源前加锁，访问之后再解锁，如下：

struct Date
{
	int _year = 0;
	int _month = 0;
	int _day = 0;
};
void test_shared_ptr1()
{
	int n = 50000;
	mutex mtx;
	std::shared_ptr<Date> sp1(new Date);

	thread t1([&]()
	{
		for (int i = 0; i < n; ++i)
		{
			std::shared_ptr<Date> sp2(sp1);
			mtx.lock();
			sp2->_year++;
			sp2->_day++;
			sp2->_month++;
			mtx.unlock();
		}
	});

	thread t2([&]()
	{
		for (int i = 0; i < n; ++i)
		{
			std::shared_ptr<Date> sp3(sp1);
			mtx.lock();
			sp3->_year++;
			sp3->_day++;
			sp3->_month++;
			mtx.unlock();
		}
	});

	t1.join();
	t2.join();

	cout << sp1.use_count() << endl;

	cout << sp1->_year << endl;
	cout << sp1->_month << endl;
	cout << sp1->_day << endl;
}

五、循环引用和weak_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. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
  4. 也就是说_next析构了，node2就释放了。
  5. 也就是说_prev析构了，node1就释放了。
  6. 但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

为了解决这个死循环的问题，就需要用到weak_ptr了。在引用计数的场景下，把节点中的_prev和_next改成weak_ptr。原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

如下：

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

在这里插入图片描述

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;
	}
    T& operator[](size_t pos)
	{
		return _ptr[pos];
	}
public:
	T* _ptr;
};

注意，上述代码中的get函数，需要将其设为const。

本篇完，青山不改，绿水长流！

风语者！平时喜欢研究各种技术，目前在从事后端开发工作，热爱生活、热爱工作。

站长推荐