C++智能指针

最新推荐文章于 2024-04-28 15:12:08 发布

幼稚园大哥大

最新推荐文章于 2024-04-28 15:12:08 发布

阅读量714

点赞数

文章标签： c++

本文链接：https://blog.youkuaiyun.com/weixin_46107667/article/details/124280615

版权

本文详细介绍了内存泄漏的概念、类型及原因，并重点探讨了C++中的智能指针，包括SmartPtr、std::auto_ptr、std::unique_ptr和std::shared_ptr的使用原理和特点。智能指针通过RAII原则自动管理内存，避免了内存泄漏问题，但同时也需要注意线程安全和循环引用等挑战。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

智能指针也是指针的一种，主要功能是将管理的资源能被对象访问，但是不会产生内存泄漏的问题。

一、内存泄漏

1.1什么是内存泄漏，内存泄漏的危害

什么是内存泄漏

内存泄漏就是因为守护造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该内存的控制，因而造成内存的浪费。
内存泄漏的危害：长期运行的程序出现内存泄漏，影响很大，如操作系统、后台服务等等，出现内存泄漏会导致响应越来越慢，最终卡死。

1.2内存泄漏类型

堆内存泄漏

堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

系统资源泄漏

指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

1.3 内存泄漏的原因

在类的构造函数和析构函数中没有匹配的调用new和delete函数，当类中存在资源时不显示调用析构函数会存在内存泄漏。
在释放对象数组时在delete中没有使用方括号[]。
在类中存在资源时不显示定义拷贝构造函数和重载赋值运算符
没有将基类的析构函数定义为虚函数。

二、智能指针的使用原理

RAII：利用对象的生命周期来控制资源，通过构造函数来获取资源管理权，通过析构函数来释放所管理的资源。
好处：

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

2.1 SmartPtr

采用RAII思想设计一个SmartPtr类

#include<iostream>
using namespace std;

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}
private:
	T* _ptr;
};
void MergeSort(int*a,int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	SmartPtr<int> sp(tmp);
}

int main()
{
	int a[5] = { 1,2,3,4,5 };
	MergeSort(a, sizeof(a));

	return 0;
}

上述代码还不能称为智能指针，因为不具有指针的行为，指针可以解引用也可以通过->去访问所指向空间内的内容，因此需要在SmartPtr类中重载*、->.

重载*、->

//重载* 、->使其像指针一样那样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}

2.2 std::auto_ptr

在C++98中提供了一种auto_ptr的智能指针

// C++库中的智能指针都定义在memory这个头文件中
#include<iostream>
#include<memory>
using namespace std;
class Date
{
public:
	Date()
	{
		cout << "Date()" << endl;
	}
	~Date()
	{
		cout << "~Date()" << endl;
	}
	int _year;
	int _month;
	int _day;
};
int main()
{
	auto_ptr<Date> ap(new Date);
	auto_ptr<Date> copy(ap);
	ap->_year = 2018;
	return 0;

	return 0;
}

auto_ptr的实现原理：管理权转移的思想。

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~AutoPtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
		//实现思想：一旦发生拷贝，就将ap中的资源转移到当前对象中，然后将ap与其所管理的资源断开
		AutoPtr(AutoPtr<T>&ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = NULL;
		}
		AutoPtr<T>& operator=(AutoPtr<T>& ap)
		{
			//检测是否是自己给自己赋值
			if (this != &ap)
			{
				if (_ptr)
				{
					delete _ptr;
				}
				_ptr = ap._ptr;
				ap._ptr = NULL;
			}
			return *this;
		}
	
		//重载* 、->使其像指针一样那样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	}
private:
	T* _ptr;
};

2.3 std::unique_ptr

unique_ptr的原理是：防拷贝，就是不让赋值和拷贝

unique_ptr实现代码

template<class T>
class UniquePtr
{
public:
	UniquePtr(T* ptr = nullptr)
		:_ptr(ptr)
	{}
	~UniquePtr()
	{
		if (_ptr)
		{
			delete _ptr;
		}
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	// C++98防拷贝的方式：只声明不实现+声明成私有
	UniquePtr(UniquePtr<T>const&);
	UniquePtr& operator=(UniquePtr<T> const&);
	//C++11中使用delete
	UniquePtr(UniquePtr<T>const&) = delete;
	UniquePtr& operator=(UniquePtr<T> const&) = delete;

};

2.4 shared_ptr

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

具体说明：

shared_ptr在其内部，给每一个资源都维护着一份计数，用来记录该份资源被几个对象共享使用。
在对象被销毁时（调用对象的析构函数），对该资源的引用计数进行减一
如果引用计数是0时，就说明自己是最后一个使用该资源的对象，当不使用的时候就将资源进行释放

实现shared_ptr

#include <thread>
#include <mutex>
template <class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pRefCount(new int(1))
		, _pMutex(new mutex)
	{}
	~SharedPtr() { Release(); }
	SharedPtr(const SharedPtr<T>& sp)
		: _ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		AddRefCount();
	}
	// sp1 = sp2
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		//if (this != &sp)
		if (_ptr != sp._ptr)
		{
			// 释放管理的旧资源
			Release();
			// 共享管理新对象的资源，并增加引用计数
			_ptr = sp._ptr;
			_pRefCount = sp._pRefCount;
			_pMutex = sp._pMutex;

			AddRefCount();
		}
		return *this;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
	int UseCount() { return *_pRefCount; }
	T* Get() { return _ptr; }
	void AddRefCount()
	{
		// 加锁或者使用加1的原子操作
		_pMutex->lock();
		++(*_pRefCount);
		_pMutex->unlock();
	}
private:
	void Release()
	{
		bool deleteflag = false;

		// 引用计数减1，如果减到0，则释放资源
		_pMutex.lock();
		if (--(*_pRefCount) == 0)
		{
			delete _ptr;
			delete _pRefCount;
			deleteflag = true;
		}
		_pMutex.unlock();

		if (deleteflag == true)
			delete _pMutex;
	}
private:
	int* _pRefCount; // 引用计数
	T* _ptr; // 指向管理资源的指针 
	mutex* _pMutex; // 互斥锁
};
int main()
{
	SharedPtr<int> sp1(new int(10));
	SharedPtr<int> sp2(sp1);
	*sp2 = 20;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	SharedPtr<int> sp3(new int(10));
	sp2 = sp3;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	cout << sp3.UseCount() << endl;
	sp1 = sp3;
	cout << sp1.UseCount() << endl;
	cout << sp2.UseCount() << endl;
	cout << sp3.UseCount() << endl;
	return 0;
}

std::shared_ptr中存在线程安全问题

因为引用计数是多个智能指针对象共享的，可能会存在同时对引用计数进行加加减减-，这个操作不是原子的，可能会引起加加或减减一次，就会造成引用计数混乱。
智能指针管理的对象存放在堆上，两个线程同时去访问，也会导致线程安全。

shared_ptr中的循环引用问题分析

在这里插入图片描述
/解决方案：在引用计数的场景下，把节点中的_prev和_next改成weak_ptr就可以了
原理就是，node1->_next = node2;和node2->_prev = node1;时weak_ptr的_next和_prev不会增加node1和node2的引用计数。

三、总结：四种智能指针的实现原理

auto_ptr、unique_ptr和shared_ptr都是通过RAII的思想来实现的，其中auto_ptr在进行赋值拷贝时会将资源进行转移，是一种由缺陷的智能指针；而unique_ptr是在auto_ptr基础上直接将拷贝构造和赋值运算符重载函数设置为delete函数，不允许外部进行赋值拷贝操作；shared_ptr是C++11中最常用的智能指针，它采用的是引用计数的方法，当记录当前资源被多个智能指针对象引用时。，当增加一个引用时引用计数就会加一，减少时就会减一。但是shared_ptr会造成循环引用的问题；第四种指针就是weak_ptr，weak_ptr就是用来解决循环引用问题。