C++智能指针之auto_ptr、unique_ptr、shared_ptr、weak_ptr的详细介绍

最新推荐文章于 2024-04-05 20:42:24 发布

一条傻傻的二哈

最新推荐文章于 2024-04-05 20:42:24 发布

阅读量1.3k

点赞数 3

分类专栏： C++ 文章标签：智能指针

本文链接：https://blog.csdn.net/qq_40421919/article/details/88832478

版权

C++ 专栏收录该内容

29 篇文章 6 订阅

订阅专栏

我们先来看看为什么需要有智能指针。看看下面的代码

void demo(std::string& str)
{
	std::string *ps = new std::string(str);
	...
	str = ps;
	return;
}

上面的代码很明显的每次调用都在分配堆上的空间，但是却从不收回，从而导致内存泄露。当然我们知道在 return；前加上delete ps;。但是万一忘了呢？或者在来看这个代码

void demo(std::string& str)
{
	std::string *ps = new std::string(str);
	if(weird_thing())
	{
		throw exception();
	}
	str = *ps;
	delete ps;
	return;
}

在上面的代码中，如果抛出了异常，那么我们的代码又会出现内存泄露的危险了。
所以引出了智能指针的概念。
RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：
1. 不需要显式地释放资源。
2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。

auto_ptr

c++98中为我们提供的智能指针。
我们先来看看auto_ptr 和常规指针的区别
我们来稍微使用一下auto_ptr，并且来看看它存在的问题。

#include <memory>
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);
	// auto_ptr的问题：当对象拷贝或者赋值后，前面的对象就悬空了
	// C++98中设计的auto_ptr问题是非常明显的，所以实际中很多公司明确规定了不能使用auto_ptr
	ap->_year = 2018; //******************会报错
	return 0;
}

要想知道为什么会出现这个问题，我们就需要从底层剖析一下原理
我们模拟实现一个auto_ptr，这个模拟的是资源管理权的转移。

//c++98
//资源管理权的转移

struct Date {
	Date() {}
	~Date() {}
	int _year;
	int _mouth;
	int _day;
};

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = NULL)
		:_ptr(ptr)
	{}
	~AutoPtr()
	{
		if (_ptr != NULL)
			delete _ptr;
	}
	AutoPtr(AutoPtr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = NULL;
	}
	AutoPtr<T>& operator=(AutoPtr<T>& ap)
	{
		// 检测是否为自己给自己赋值
		if (this != &ap)
		{
			// 释放当前对象中资源
			if (_ptr)
				delete _ptr;
			// 转移ap中资源到当前对象中
			_ptr = ap._ptr;
			ap._ptr = NULL;
		}
		return *this;
	}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
private:
	T* _ptr;
};

int main()
{
	AutoPtr<Date> ap(new Date);
	// 现在再从实现原理层来分析会发现，这里拷贝后把ap对象的指针赋空了，导致ap对象悬空
	// 通过ap对象访问资源时就会出现问题。
	AutoPtr<Date> copy(ap);
	ap->_year = 2018;
	return 0;
}

我们可以它底层的原理就是：在进行拷贝构造或者赋值的时候，比如说将s1赋值给s2，就相当于将s1的资源管理权交给s2，然后将s1的指针置为空，还是一份资源，还是一个指针s2指着它。但是导致的一个问题就是此时的s1为空了，如果在使用s1就会出错。
这种将一块空间的权限完全交给别人的方法：产生问题的是拷贝构造和赋值运算符重载函数。当调用了拷贝构造或是赋值运算符的重载函数任意一个时：假设调用了拷贝构造函数，我们的本意是用一个对象去构造一个与之一模一样的对象，可是结果呢，我们把自己给弄丢了，完全没有达到我们预期的目标。所以当我们在上述代码中的Test1中调用了拷贝构造函数时，如果我们想要修改第一次构造出来的对象的内容时，会发现对象的资源已经被清理了，所以会导致程序崩溃。
另外一种实现auto_ptr的方式是资源释放权的转移。

template<class T>
class AutoPtr
{
public:
	AutoPtr(T* ptr = 0)//构造函数
		:_ptr(ptr)
		, _owner(true)//当独占资源时将其设置为true
	{
		if (!_ptr)
		{
			_owner = false;
		}
	}

	AutoPtr(const AutoPtr<T>& ap)//拷贝构造函数
		:_ptr(ap._ptr)
		, _owner(true)
	{
		ap._owner = false;
	}

	AutoPtr& operator=(const AutoPtr<T>& ap)//赋值运算符重载
	{
		if (this != &ap)
		{
			delete _ptr;
			_owner = true;
			_ptr = ap._ptr;
			ap._owner = false;
		}
		return *this;
	}

	~AutoPtr()
	{
		if (_owner)
		{
			delete _ptr;
			_ptr = NULL;
			cout << "~AutoPtr()" << endl;
		}
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	mutable bool _owner;//可被修改的
};

void TestAutoPtr()
{
	AutoPtr<int> ap4(AutoPtr<int>(new int(20)));
	if (true)
	{
		AutoPtr<int> ap5(ap4);
	}//作用域结束之后ap5已被析构，空间已被释放
	*ap4 = 10;//这时ap5与ap4共享一块空间，既然ap5已被释放，那么ap4对象维护的指针已成为野指针
}

int main()
{
	TestAutoPtr();
	return 0;
}

我们使用一个状态位 state 来标识资源资源释放权的转移，比如，起初s1有资源，并且有资源的释放权，但是将s2赋给s1的时候，相当于s1和s2指向了同一块内存资源。但是此时s2没有资源的释放权，只有s1才能释放资源。s2变成了野指针。
这种方法解决了上一种方法的没有资源，访问空指针出错的问题。
但是第二种方法有一种致命的问题就是，程序虽然可以正常的运行，但是野指针可以篡改数据，并且不会报错。导致程序出错并且难以发现。所以第一种方法相较与第二种好一点，最起码他会报错。
库中的源码我就不分析了。大家有兴趣可以参照：https://blog.csdn.net/qq_34992845/article/details/68939527

unique_ptr

我们可以看到auto_ptr 的问题出在了拷贝构造和复制拷贝这两个函数上，那么unique_ptr 提供了简单粗暴的方法，就是直接防止拷贝。
c++11中提出的。

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;
private:
	T * _ptr;
};

那么只要让用户不调用这两个函数就好了，嗯嗯，确实够粗暴的。

shared_ptr

我们再来看看更加靠谱的智能指针，同样也是c++11提出来的。
shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

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

#include <thread>
#include <mutex>

template <class T>
class SharedPtr
{
public:
	SharedPtr(T* ptr = nullptr)
		: _ptr(ptr)
		, _pRefCount(new int(1))
		, _pMutex(new mutex)
	{
		// 如果是一个空指针对象，则引用计数给0
		if (_ptr == nullptr)
			*_pRefCount = 0;
	}
	~SharedPtr()
	{
		Release(); 
	}

	SharedPtr(const SharedPtr<T>& sp)
		: _ptr(sp._ptr)
		, _pRefCount(sp._pRefCount)
		, _pMutex(sp._pMutex)
	{
		// 如果是一个空指针对象，则不加引用计数，否则才加引用计数
		if (_ptr)
			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;
			if (_ptr)
				AddRefCount();
		}
		return *this;
}
	T& operator*() { return *_ptr; }
	T* operator->() { return _ptr; }
	int UseCount() { return *_pRefCount; }
	T* Get() { return _ptr; }
	int AddRefCount()
	{
		// 加锁或者使用加1的原子操作
		_pMutex->lock();
		++(*_pRefCount);
		_pMutex->unlock();
		return *_pRefCount;
	}
	int SubRefCount()
	{
		// 加锁或者使用减1的原子操作
		_pMutex->lock();
		--(*_pRefCount);
		_pMutex->unlock();
		return *_pRefCount;
	}
private:
	void Release()
	{
		// 引用计数减1，如果减到0，则释放资源
		if (_ptr && SubRefCount() == 0)
		{
			delete _ptr;
			delete _pRefCount;
		}
	}
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;  //2
	cout << sp2.UseCount() << endl;  //2
	SharedPtr<int> sp3(new int(10));
	sp2 = sp3;
	cout << sp1.UseCount() << endl;  //1
	cout << sp2.UseCount() << endl;  //2
	cout << sp3.UseCount() << endl;  //2
	sp1 = sp3;
	cout << sp1.UseCount() << endl;  //3
	cout << sp2.UseCount() << endl;  //3
	cout << sp3.UseCount() << endl;  //3
	return 0;
}

我们发现通过引用计数的方式，很好的解决了上面的两个智能指针的问题。不需要再防止复制拷贝或者拷贝构造带来的问题。
大家可以看到上面的代码中，在引用计数++或者 - - 时，我们给他加锁了。

智能指针对象中引用计数是多个智能指针对象共享的，两个线程中智能指针的引用计数同时++或 - -，如果这个操作不是原子的，引用计数原来是1，++了两次，可能还是2.这样引用计数就错乱了。会导致资源未释放或者程序崩溃的问题。所以智能指针中引用计数++、- - 是需要加锁的，也就是说引用计数的操作是线程安全的。
智能指针管理的对象存放在堆上，两个线程中同时去访问，会导致线程安全问题。

但是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;  //1
	cout << node2.use_count() << endl;  //1
	node1->_next = node2;
	node2->_prev = node1;
	cout << node1.use_count() << endl; // 2
	cout << node2.use_count() << endl;  // 2
	return 0;
}

我们用一个双向链表来模拟，当node1的后向指针指向node2，而node2的前向指针指向node1，就会导致两个指针的引用计数都加1，但是此时不管是node1还是node2所指向的资源都只有一份。但是两个引用计数都为2。就会导致内存泄露。
这就是循环引用的问题。

node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。
node1的_next指向node2，node2的_prev指向node1，引用计数变成2。
node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。
也就是说_next析构了，node2就释放了。
也就是说_prev析构了，node1就释放了。
但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。都在等着对方说释放。

weak_ptr

这时我们引入了另外一个只能指针 weak_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;  // 1
cout << node2.use_count() << endl;  // 1
node1->_next = node2;
node2->_prev = node1;
cout << node1.use_count() << endl;  // 1
cout << node2.use_count() << endl;  // 1
return 0;
}

我们看到将prev和next改成weak_ptr后，当存在循环引用的时候引用计数也不会加错了，为什么？weak_ptr 怎么就这么神奇呢?
我们先来区分一下shared_ptr和weak_ptr。
shared_ptr与weak_ptr智能指针均是C++ RAII的一种应用，可用于动态资源管理
shared_ptr基于“引用计数”模型实现，多个shared_ptr可指向同一个动态对象，并维护了一个共享的引用计数器，记录了引用同一对象的shared_ptr实例的数量。当最后一个指向动态对象的shared_ptr销毁时，会自动销毁其所指对象(通过delete操作符)。
shared_ptr的默认能力是管理动态内存，但支持自定义的Deleter以实现个性化的资源释放动作。（下面将介绍他的删除器）
weak_ptr用于解决“引用计数”模型循环依赖问题，weak_ptr指向一个对象，并不增减该对象的引用计数器。
weak_ptr更像是shared_ptr的助手：

他不像其余三种，可以通过构造函数直接分配对象内存；他必须通过shared_ptr来共享内存。
没有重载opreator*和->操作符，也就意味着即使分配到对象，他也没法使用该对象
不主动参与引用计数，即，share_ptr释放了，那么weak_ptr所存的对象也释放了。
使用成员函数use_count()可以查看当前引用计数，expired()判断引用计数是否为空。
lock()函数，返回一个shared_ptr智能指针：也就是让weak_ptr观测shared_ptr智能指针，并且在需要时候通过lock函数返回一个shared_ptr。

我们最后在来看看shared_ptr的删除器，因为如果资源不是new出来的，或者资源是malloc出来的，或者是new[] 出来的，或者是一个文件描述符呢？所以我们自定义删除器为了将这些不同的申请出来的空间一一释放。

//malloc出来的空间
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

//new[] 出来的空间
template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

//文件描述符
template<class T>
struct ClosefdFunc{
	void operator()(T* fd)
	{
		cout << "close fd" << fd << endl;
		fclose(fd);
	}
};

void TestFunc()
{
	FreeFunc<int> freeFunc;
	shared_ptr<int> sp1((int*)malloc(4), freeFunc);

	DeleteArrayFunc<int> deleteArrayFunc;
	shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);

	ClosefdFunc<FILE> closefdFunc;
	shared_ptr<FILE> sp3(fopen("myfile.txt","w"),closefdFunc);
}

int main()
{
	TestFunc();
	return 0;
}

定制删除器我们可以把不同的申请出来的空间进行不同的处理。

一条傻傻的二哈

关注

3
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
C++智能指针之auto_ptr、unique_ptr、shared_ptr、weak_ptr的详细介绍

我们先来看看为什么需要有智能指针。看看下面的代码void demo(std::string& str){ std::string *ps = new std::string(str); ... str = ps; return;}上面的代码很明显的每次调用都在分配堆上的空间，但是却从不收回，从而导致内存泄露。当然我们知道在 return；前加上delete ps;。...
复制链接

扫一扫