【C++】智能指针详解

最新推荐文章于 2024-09-22 17:30:30 发布
最新推荐文章于 2024-09-22 17:30:30 发布
阅读量9.9k 收藏 144
点赞数 37
分类专栏： C++ 文章标签： C++ 数据结构 智能指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53268869/article/details/124551345
版权

今天我们来讲一下c++中的智能指针。

目录

1. 智能指针初识

1.1 什么是智能指针

智能指针不是指针，是一个管理指针的类，用来存储指向动态分配对象的指针，负责自动释放动态分配的对象，防止堆内存泄漏。

动态分配的资源，交给一个类对象去管理，当类对象声明周期结束时，自动调用析构函数释放资源

1.2 智能指针发展历史

  1. C++ 98 中产生了第一个智能指针auto_ptr
  2. C++boost给出了更加实用的scoped_ptr 和 shared_ptr 和 weak_ptr
  3. C++ 11 引入了unquie_ptr 和 shared_ptr 和 weak_ptrt .需要注意的是，unique_ptr对应的是boost中的scoped_ptr。并且这些智能指针的实现是参照boost中的实现的。

1.3 为什么需要智能指针

在之前的博客 【C++】异常 中我提到过一个叫做异常的重新抛出的场景：

我们再把那个例子讲一下：


void File()
{
	string filename;
	cin >> filename;
	FILE* fout = fopen(filename.c_str(), "r");
	if (fout == nullptr) {
		string errmsg = "打开文件失败：";
		errmsg += filename;
		errmsg += "->";
		errmsg += strerror(errno);
		Exception e(errno, errmsg);
		throw e;
	}
	char ch;
	while ((ch = fgetc(fout))!=EOF) {
		cout << ch;
	}
	fclose(fout);
}

double Division(int a, int b)
{
	if (b == 0) 
	{
		string errmsg = "Division by zero condition!";
		Exception e(100, errmsg);
		throw e;
	}
	else
	{
		return ((double)a / (double)b);
	}
}

void Func()
{
	int* p = new int[100];
	int len, time;
	cin >> len >> time;
	try {
		cout << Division(len,time) << endl;
		File();
	}
	catch (...)
	{
		//捕获之后，不是要处理异常，异常由最外层同一处理
		//这里捕获异常只是为了处理内存泄漏的问题
		delete[]p;
		throw; 
	}
	delete[]p;
}

int main()
{

	try {
		Func();
	}
	catch (const Exception& e) {
		cout << e.what() << endl;
	}
	catch (...)
	{
		cout << "未知异常" << endl;
	}
	return 0;
}

在Func函数中，我们在堆上创建了开一个指针，为了防止函数抛出异常导致最后的 析构函数不执行而产生野指针，我们使用了 异常的重新抛出策略。

但是，终究不是个好的方法，如果这类资源较多，那么我们需要大量的 异常重抛 ，而且就算程序不涉及程序处理，大量的堆上空间需要人工释放，容易造成疏漏，这一问题在工程中比较常见。

所以，这时候如果我们实用智能指针，就可以不用再操心内存是否会泄露的问题

3. 智能指针原理

3.1 RALL

RAII 是 resource acquisition is initialization 的缩写，意为“资源获取即初始化”。它是 C++ 之父 Bjarne Stroustrup 提出的设计理念，其核心是把资源和对象的生命周期绑定，对象创建获取资源，对象销毁释放资源。在 RAII 的指导下，C++ 把底层的资源管理问题提升到了对象生命周期管理的更高层次。

借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

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

我们可以借助RALL思想来写一个简单的 智能指针：

#include<iostream>
using namespace std;

template<class T>
class SmartPtr
{
public:
	SmartPtr(T* ptr =nullptr)
		:_ptr(ptr)
	{}
	~SmartPtr()
	{
		if (_ptr)delete _ptr;
		cout<<"~SmartPtr"<<endl;
	}
private:
	T* _ptr;
};

int main()
{
	int* a = new int(1);
	SmartPtr<int> sp(a); //将a 指针委托给sp对象管理

	SmartPtr<int>sp2(new int(2)); //直接船舰匿名对象给sp2管理
}

3.2 智能指针的分类

上面的SmartPtr 还不可以被称为智能指针，因为它还不具有指针的行为与性质。

指针可以解引用，也可以通过->去访问所指向的空间中的内容，因此智能指针还需要将 *,->重载。

除此之外，如果我们使用了 拷贝或者赋值操作，就会发生浅拷贝的问题，由于二者指向同一块空间，所以在析构的时候也会析构两次，造成错误。

在这里插入图片描述
所以，为了解决以上问题，C++提供了几种设计方案实现的智能指针，我们下面来一一讲解。

C++中存在4种智能指针：auto_ptr,unquie_ptr,shared_ptr,weak_ptr，他们各有优缺点，以及对应的实用场景。

3.2.1 auto_ptr

在C++98版本的库种，提供了 auto_ptr 的智能指针：

我们使用一下std::auto_ptr:

class Date
{
public:
	Date()
		:_year(0),_month(0),_day(0)
	{}
	~Date(){}

	int _year;
	int _month;
	int _day;

};

int main()
{
	auto_ptr<Date>ap(new Date);

	//拷贝构造
	auto_ptr<Date>copy(ap);
	
	ap->_year = 2022;
}

我们发现报错了，发生了非法访问。

这就是auto_ptr 的弊病，当我们使用对象拷贝或者赋值之后，之前的那个对象就被置空（如下图）

在这里插入图片描述
在拷贝或者赋值的过程种，auto_ptr 会传递所有权，将资源全部从源指针转移给目标指针，源指针被置空。

虽然这种方法确实解决了 浅拷贝的问题，但是十分局限性也很大，这也就导致了，我们使用auto_ptr的时候要注意，不要对源指针进行访问或者操作。

由于C++98种提供的这个智能指针问题明显，所以在实际工作种哼多公司是明确规定了不能使用auto_ptr的。

那么auto_ptr具体是如何实现的呢？很简单.

template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr=nullptr)
			:_ptr(ptr)
		{}
		
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr; //管理权转移
		}

		auto_ptr<T>& operator = (auto_ptr<T>& ap)
		{
			if (this != *ap) {
				delete _ptr;
				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}
			return *this;
		}

		~SmartPtr()
		{
			if (_ptr)delete _ptr;
		}
		T& operator *()
		{
			return *_ptr;
		}
		T* operator ->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

3.2.2 unique_ptr

在C++11中，C++11y引入了unique_ptr.

unique_ptr的原理很简单，就是一个“得不到就毁掉”的理念，直接把拷贝和赋值禁止了。

对于用不上赋值拷贝的场景的时候，我们选择unique_ptr也是一个不错的选择。

我们可以尝试实现一下：

template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}

		//防拷贝
		unique_ptr(unique_ptr<T>& ap) = delete;
		unique_ptr<T>& operator = (unique_ptr<T>& ap) = delete;

		~SmartPtr()
		{
			if (_ptr)delete _ptr;
		}

		T& operator *()
		{
			return *_ptr;
		}
		T* operator ->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

3.2.3 shared_ptr

3.2.3.1 shared_ptr 原理

C++中还提供了shared_ptr。

shared_ptr 是当前最为广泛使用的智能指针，它可以安全的提供拷贝操作。

我们可以测试使用一下：
在这里插入图片描述

那么shared_ptr的原理是什么？

我们可以对一个资源添加一个计数器，让所有管理该资源的智能共用这个计数器，倘若发生拷贝，计数器加一，倘若有析构发生， 计数器减一，当计数器等于0的时候，就把对象析构掉。

再具体一点：

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

我们可以实现一个简单的shared_ptr:

template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T*ptr =nullptr)
			:_ptr(ptr),_pcount(new int(1))
		{}
		//拷贝构造
		shared_ptr(const T& sp)
			_ptr(sp._ptr),_pcount(sp._pcount)
		{
			++(*_pcount);
		}
		//赋值拷贝
		shared_ptr<T>& operator = (shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr) {
				if (--(*_pcount) == 0){
					delete _pcount;
					delete _ptr;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				++(*_pcount);
			}
			return *this;
		}
		T& operator *()
		{
			return *_ptr;
		}

		T* operator ->()
		{
			return _ptr;
		}


		~shared_ptr()
		{
			if (--(*_pcount) == 0 && _ptr) {
				delete _pcount;
				delete _ptr;
			}
		}
	private:
		T* _ptr;
		int* _pcount;
	};

我们把 这个 计数器 建在堆上，这样就可以保证各个对象之间保持同步同时计数正确。

-拷贝构造

在这里插入图片描述

  • 赋值拷贝

赋值拷贝需要注意两点：

  1. 在被赋值之前的对象需要将自己析构，也就是放弃当前资源的管理权，然后再去被赋值，取得新的管理权。
  2. 避免自己对自己赋值，按照1中的机制，如果自己对自己赋值，会造成无谓的操作，或者误析构资源。

在这里插入图片描述
其他写法：

		shared_ptr<T>& operator=(shared_ptr<T> sp)
		{
			swap(_ptr, sp._ptr);
			swap(_pcount, sp._pcount);
			return *this;
		}

但是，此时我们的shared_ptr 还面临着 线程安全的问题。

这里我们需要保障的是对于 计数器的 ++ 和 – 造成的线程不安全。对于资源的线程安全问题，这不是智能指针保证的部分。


	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr), _pcount(new int(1)), _pmtx(new mutex)
		{}

		void add_ref()
		{
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();
		}
		void release_ref()
		{
			bool flag = false;
			_pmtx->lock();
			if (--(*_pcount) == 0 && _ptr) {
				delete _pcount;
				delete _ptr;
				flag = true;
				cout << "释放资源：" << _ptr << endl;
			}
			_pmtx->unlock();
			if (flag)delete _pmtx;
		}

		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr),_pcount(sp._pcount),_pmtx(sp._pmtx)
		{
			add_ref();
		}
		shared_ptr<T>& operator = (const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr) {
				if (--(*_pcount) == 0){
					delete _pcount;
					delete _ptr;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				add_ref();
			}
			return *this;
		}
		T& operator *()
		{
			return *_ptr;
		}

		T* operator ->()
		{
			return _ptr;
		}

		T* get()
		{
			return _ptr;
		}
		int use_count()
		{
			return *_pcount;
		}


		~shared_ptr()
		{
			release_ref();
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};
3.2.3.3 定制删除器

不管是我们自己实现的shared_ptr还是库中的shared_ptr,我们在析构的时候默认都是 delete _ptr,如果我们托管的类型是 new T[] ,或者 malloc出来的话，就导致类型不是匹配的，无法析构。

为此，shared_ptr提供了 定制删除器，我们可以在构造的时候作为参数传入。如果我们不传参，就默认使用delete
在这里插入图片描述

这里举两个例子


	template<class T>
	struct DeleteArray
	{
		void operator()(T* ptr)
		{
			delete[]ptr;
		}
	};
	
	void test_deletor()
	{
		DeleteArray<string>da; //使用仿函数定制
		std::shared_ptr<string>s2(new string[10], da);

		std::shared_ptr<string>s3((string*)malloc(sizeof(string)),
		 [](string* ptr) {free(ptr); }); //使用lamdba 定制
	}

如果我们也想自己是想一下呢？

当然是可以的，但是由于我们的实现比库中的简单很多（库中使用多个类），所以我们难以通过传参的方式来定制删除器，我们增加一个模板参数，通过向模板传参来达到相同的目的。

std的框架设计底层用一个类专门管理资源计数，所以它们可以在构造函数传参，把删除器类型传递给专门管理资源的这个类。而我们是一体化的。

template<class T>
	struct DefaultDel
	{
		void operator ()(T* ptr)
		{
			delete ptr;
		}
	};
	
	template<class T,class D=DefaultDel<T>> //增加模板参数
	class shared_ptr
	{
	public:
		explicit shared_ptr(T* ptr = nullptr)
			:_ptr(ptr), _pcount(new int(1)), _pmtx(new mutex)
		{}

		void add_ref()
		{
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();
		}
		void release_ref()
		{
			bool flag = false;
			_pmtx->lock();
			if (--(*_pcount) == 0 && _ptr) {
				//定制化删除
				D del;
				del(_ptr);
				
				delete _pcount;
				flag = true;
				cout << "释放资源：" << _ptr << endl;
			}
			_pmtx->unlock();
			if (flag)delete _pmtx;
		}

		shared_ptr(const shared_ptr<T,D>& sp)
			:_ptr(sp._ptr),_pcount(sp._pcount),_pmtx(sp._pmtx)
		{
			add_ref();
		}
		shared_ptr<T,D>& operator = (const shared_ptr<T,D>& sp)
		{
			if (_ptr != sp._ptr) {
				if (--(*_pcount) == 0){
					delete _pcount;
					delete _ptr;
				}
				_ptr = sp._ptr;
				_pcount = sp._pcount;
				add_ref();
			}
			return *this;
		}
		T& operator *()
		{
			return *_ptr;
		}

		T* operator ->()
		{
			return _ptr;
		}

		T* get()
		{
			return _ptr;
		}
		
		int use_count()
		{
			return *_pcount;
		}
		
		~shared_ptr()
		{
			release_ref();
		}
	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};

此时我们要这样使用:


	template<class T>
	struct DeleteArray
	{
		void operator()(T* ptr)
		{
			delete[]ptr;
		}
	};
	
	void test_deletor()
	{
	 	//使用lamdba 定制
		DeleteArray<string>da; 
		std::shared_ptr<string，DeleteArray<string>>s2(new string[10);

		 //使用lamdba 定制
		auto ffree =  [](string* ptr) {free(ptr); };
		std::shared_ptr<string,decltype(ffree)>s3((string*)malloc(sizeof(string)));
		
		auto fclose =  [](FILE* ptr) {fclose(ptr); };
		std::shared_ptr<string,decltype(ffcolse)>s3(fopen("test.cpp","r"));
	}

3.2.4 weak_ptr

虽然 shared_ptr 确实已经是一个不错的设计了，但是没有“十全十美”的东西，在一些特别的场景之下shared_ptr 也无能为力：

  • shared_ptr 的循环引用
    我们看下面的场景，我们运行发现，两个节点n1.n2 都没有析构。
    在这里插入图片描述

为什么会发生这种情况呢？
在这里插入图片描述

在出了作用域之后，首先把 n1,n2 两个对象析构，此时两边计数器均减为1，那么左边节点资源什么时候析构呢, 当n2->prev析构，也就是当右边节点资源析构，那么右边节点资源什么时候析构呢，当n1->_next析构，也就是当左边节点资源析构…我们发现，此时形成了一个类似于“死锁”的情况。

此时我们就要使用 weak_ptr 来解决 循环引用。

weak_ptr是一个弱引用，它是为了配合shared_ptr而引入的一种智能指针，是为了解决循环引用而生的，为什么这么说呢，我们可以看看它的构造函数：

我们只能使用 wek_ptr或者 shared_ptr 去初始化它。
在这里插入图片描述

我们在会产生循环引用的位置，把shared_ptr换成weak_ptr。 weak_ptr 不是一个RALL智能指针，它不参与资源的管理，他是专门用来解决引用计数的，我们可以使用一个shared_ptr 来初始化一个weak_ptr,但是weak_ptr 不增加引用计数，不参与管理，但是也像指针一样访问修改资源。

在这里插入图片描述

我们可以自己实现一个weak_ptr:


	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}
		weak_ptr(shared_ptr<T>& sp)
			:_ptr(sp.get()),_pcount(sp.use_count())
		{}
		weak_ptr(weak_ptr<T>& sp)
			:_ptr(sp._ptr), _pcount(sp._pcount)
		{}
		weak_ptr& operator = (shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			_pcount = sp.use_count();
			return *this;
		}
		weak_ptr& operator = (weak_ptr<T>& sp)
		{
			_ptr = sp._ptr;
			_pcount = sp._pcount;
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		int use_count()
		{
			return *_pcount;
		}
	private:
		T* _ptr;
		int* _pcount;

	};
Ornamrr
关注
专栏目录
【C++】智能指针
须知少日拏云志，曾许人间第一流。
06-06 1032
在我们异常一节就已经讲过，当使用异常的时候，几个函数层层嵌套，其中如果抛异常就可能导致没有释放堆区开辟的空间。这样就很容易导致内存泄漏。关于内存泄漏，我也曾在C++内存管理一文中写过。为了觉得这个问题，C++引入了智能指针。
c++智能指针详解
H_Strong的博客
03-23 2631
c++智能指针 文章目录c++智能指针为什么要有智能指针？智能指针有哪些实现版本auto_ptr 的实现版本1auto_ptr 的实现版本2两种 auto_ptr 的对比unique_ptr 的实现版本shared_ptr 和 weak_ptrshared_ptr 的简单实现shared_ptr线程安全问题shared_ptr在双向循环链表中引起的循环引用问题weak_ptr帮助shared_p...
C++中智能指针的设计和使用
编程资料大全
05-12 353
智能指针(smart pointer)是存储指向动态分配（堆）对象指针的类，用于生存期控制，能够确保自动正确的销毁动态分配的对象，防止内存泄露。它的一种通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象共享同一指针。每次创建类的新对象时，初始化指针并将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造...
C++智能指针详解
最新发布
weixin_53903743的博客
09-22 953
看下面的例子：若p1处new抛异常，则相当于p1的new没有成功，则什么都不用做若p2处new抛异常，则相当于p2的new没有成功，而p1的new成功了，所以需要释放p1，然后再重新抛出若div处抛异常，则将p1与p2都释放，再将其重新抛出可以看出处理起来非常麻烦，存在内存泄漏的问题(只进行new，但没有delete)第二个new抛异常要释放第一个new，div抛异常要释放前两个new若再添加一个new，则又会存在new抛异常的问题，还需添加 try catch。
C++中的智能指针
Balaam' s blogs
02-25 503
C++中的智能指针
C++：智能指针
weixin_43908419的博客
06-06 7370
本文介绍了智能指针的概念和原理，以及C++标准库中的auto_ptr、unique_ptr和shared_ptr三种智能指针，分析了shared_ptr中的循环引用问题，并由shared_ptr的循环引用问题出发点，介绍了weak_ptr。
C++智能指针
gehulushang的博客
01-06 193
智能指针的由来： 除了静态内存和栈内存外，每个程序还有一个内存池，这部分内存被称为自由空间或者堆。程序用堆来存储动态分配的对象即那些在程序运行时分配的对象，当动态对象不再使用时，我们的代码必须显式的销毁它们。 在C++中，动态内存的管理是用一对运算符完成的：new和delete，new:在动态内存中为对象分配一块空间并返回一个指向该对象的指针，delete：指向一个动态独享的指针，销毁对象，并...
C++智能指针详解abc
08-24
C++智能指针详解 标题解释 "C++智能指针详解abc"这一标题表明，本文将详细介绍C++中的智能指针机制，包括其概述、原理、使用方法和结论等方面。 描述解释 "C++智能指针详解abc"这一描述表明，本文将对C++中的智能...
C++智能指针详解.pdf
02-27
C++智能指针是C++标准库中用于自动管理动态分配内存的对象，它们的主要目标是解决C++中手动内存管理的挑战，特别是防止内存泄漏。智能指针在生命周期结束时会自动调用删除器（deleter）来释放其所指向的对象，确保...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++智能指针
02-24
c++中关于auto_ptr指针的详细讲解，指针的含义以及用法还有架构都清晰的给出了解释的操作
C++ 智能指针
温暖不了你的心的博客
01-17 3822
简介 C++11 智能指针 文章目录简介C++11 智能指针前言一、什么是智能指针？二、智能指针的原理三、什么是智能指针循环引用？1.未循环引用情况1.1 代码如下1.2 结果如下2.循环引用情况2.1 代码如下2.2 结果如下四、智能指针循环引用会导致什么问题？五、怎么解决智能指针循环引用问题？1.方法2. 代码如下3. 结果五、成员方法调用问题1. 场景2. 代码如下3. 结果总结 前言 一、什么是智能指针？ shared_ptr 强智能指针，可以改变资源的引用计数 weak_ptr 弱智能指针
c++中的智能指针
newyher的专栏
03-19 1048
c++中的智能指针C++11中新增的智能指针unique_ptrshared_ptrweak_ptr功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 C++11中新增的智能指针 c++是一门讲究效率的语言，这就导致很多的内存管理需要
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Ornamrr

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值