C++ 智能指针

最新推荐文章于 2024-08-16 23:16:42 发布
原创 最新推荐文章于 2024-08-16 23:16:42 发布 · 462 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了C++中的智能指针，包括RAll思想、智能指针的作用以及如何解决浅拷贝问题。详细讲解了auto_ptr、unique_ptr、shared_ptr的实现原理和应用场景，其中unique_ptr通过禁止拷贝和赋值防止浅拷贝，shared_ptr则通过引用计数实现资源共享。文章还提到了shared_ptr的线程安全问题和循环引用问题，并介绍了weak_ptr如何解决循环引用。

智能指针

智能指针的使用以及原理：
智能指针的思想：RAll
RAll是一种利用对象声明周期来控制程序资源的一种技术。它可以在对象构造时获取资源，在对象析构时候释放资源，完全不用用户自己释放，当然也解决了用原生态指针的缺陷。
RAll思想的好处：
1.不用自己显示释放申请的资源，用户不用考虑什么术后该释放资源，将这些交给编译器即可。
2.用这种方法，对象所需的资源在其生命周期内始终保持有效。

下面我们用RAll思想来设计一个智能指针：

template<class T>
class Sptr
{
public:
	Sptr(T* ptr=nullptr)
		:_ptr(ptr)
	{}
	~Sptr()
	{
		if (_ptr)
		{
			delete _ptr;
			_ptr = nullptr;
		}
	}
	T* operator->()const//智能指针也是指针，也要有指针的基本功能
	{
		return _ptr;
	}
	T& operator*()const 
	{
		return *_ptr;
	}
private:
	T* _ptr;
};

上述是一个基本的智能指针。我们可以发现，因为涉及资源管理，所以当用一个指针去拷贝另一个指针时，就会产生浅拷贝，并且不能用深拷贝来解决。

因此综上所述我们可以得出在所有不同的智能指针中：
1.因为RAll思想，资源可以自动释放
2.定义的智能指针类中，必须有普通指针类似的行为：operator*()以及operator->()
3.解决浅拷贝

auto_ptr
为了解决浅拷贝的问题，在C++98中，提供了auto_ptr智能指针。
注：所有C++库中智能指针都定义在memory这个头文件中。

通过使用auto_ptr我们可以发现，其解决浅拷贝方式是：资源转移，也就是所拷贝结束后，前面的指针置为空。只有后面的指针有地址。

下面我们来实现这个智能指针：

//模拟智能指针
namespace My
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
		~auto_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
				_ptr = nullptr;
			}
		}

		T* operator->()const//智能指针也是指针，也要有指针的基本功能
		{
			return _ptr;
		}
		T& operator*()const
		{
			return *_ptr;
		}
		auto_ptr(auto_ptr<T>& p)//此处参数前面不能用const，因为要将前面的指针值为空
			: _ptr(p._ptr)
		{
			p._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& p)
		{
			if (this != &p)
			{
				if (_ptr)
					delete _ptr;
				_ptr = p._ptr;//赋值
				p._ptr = nullptr;//断开前面指针
			}
			return *this;
		}
	private:
		T* _ptr;
	};
}

上述就是auto_ptr的模拟实现。但是我们发现因为把前面的指针已经与资源断开练联系，所以无法操作自己的资源。这也就是资源转移的缺陷，所以这种类型的auto_ptr在很多情况下不能用。

在解决浅拷贝时，除了上述资源转移的方法，还有一种方法也可以解决浅拷贝——加一个判定条件，让资源只释放一次。
我们来实现一下这个代码：

//模拟第二种解决办法
namespace My
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			, adjust(false)
		{
			if (_ptr)
				adjust = true;
		}
		~auto_ptr()
		{
			if (_ptr&&adjust)
			{
				delete _ptr;
				_ptr = nullptr;
			}
		}

		T* operator->()const//智能指针也是指针，也要有指针的基本功能
		{
			return _ptr;
		}
		T& operator*()const
		{
			return *_ptr;
		}
		auto_ptr(const auto_ptr<T>& p)//此处不用改变参数中的资源，但函数中需要访问判定条件，则给adjust前加mutable关键字即可
			: _ptr(p._ptr)
			, adjust(p.adjust)
		{
			p.adjust = false;
		}
		auto_ptr<T>& operator=(const auto_ptr<T>& p)
		{
			if (this != &p)
			{
				if (_ptr&&adjust)
					delete _ptr;

				_ptr = p._ptr;//赋值
				adjust = p.adjust;
				p.adjust = false;
			}
			return *this;
		}
	private:
		T* _ptr;
		mutable bool adjust;
	};
}

上述为第二种解决浅拷贝的办法：加个判定条件，让资源只释放一次。但这种方法也有缺陷：有可能造成野指针，从而使代码崩溃。

unique_ptr
虽然auto_ptr解决了浅拷贝问题，但还是存在很多缺陷。所以在C++11中提供了更靠谱的智能指针unique_ptr。

unique_ptr解决浅拷贝的方式：资源独占(只能一个对象使用，不能共享)也就是禁止调用拷贝构造和赋值运算符重载，使其不能拷贝以及赋值。（防拷贝）

下面来重点模拟实现一下unique_ptr：

namespace My
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
				_ptr = nullptr;
			}
		}

		T* operator->()const//智能指针也是指针，也要有指针的基本功能
		{
			return _ptr;
		}
		T& operator*()const
		{
			return *_ptr;
		}
		/*
		C++98中
		将拷贝构造函数和赋值构造函数只声明，可以让外部无法实现拷贝以及赋值，
		但是用户有可能自己在类外定义，所以拷贝构造函数和赋值构造函数必须给定为private权限，这样用户
		就不会在类外调用拷贝构造函数
	private:
		unique_ptr(const unique_ptr<T>& up);
		unique_ptr<T>& operator=(const unique_ptr<T>&);*/

		// C++11 禁止调用拷贝构造和赋值运算符重载，可以在函数后 =delete
		unique_ptr(const unique_ptr<T>&) = delete;  //默认成员函数 = delete ： 告诉编译器，删除该默认成员函数
		unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;

	private:
		T* _ptr;
	};
}

上述为unique_ptr解决浅拷贝的方法，这种方法虽然有些直接，但解决了浅拷贝以及之前的缺陷。

另外在释放资源期间，由于我们开辟的空间的方式不同，所以如果将释放资源的方式，固定成delete释放，就只能管理new出来的空间，不能任意处理其他类型的资源了。所以需要用仿函数让释放资源的方式丰富起来，使其指针更智能。也就是定制一个删除器。

以下是代码模拟：

template<class T>
class DFDef//用仿函数，定制出只对new出来的资源进行释放
{
public:
	void operator()(T*& ptr)
	{
		if (ptr)
		{
			delete ptr;
			ptr = nullptr;
		}
	}
};
template<class T>//只对malloc、calloc、realloc出来的资源进行释放
class FREE
{
public:
	void operator()(T*& ptr)
	{
		if (ptr)
		{
			free(ptr);
			ptr = nullptr;
		}
	}
};
class FCLOSE//只对文件开始的资源进行释放
{
public:
	void operator()(FILE*& ptr)
	{
		if (ptr)
		{
			fclose(ptr);
			ptr = nullptr;
		}
	}
};
namespace My
{
	template<class T, class df = DFDef<T>>//默认为对new申请的资源进行释放
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr)
			{
				df d;
				d(_ptr);
			}
		}
		T* operator->()const//智能指针也是指针，也要有指针的基本功能
		{
			return _ptr;
		}
		T& operator*()const
		{
			return *_ptr;
		}
		unique_ptr(const unique_ptr<T>&) = delete; 
		unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;
	private:
		T* _ptr;
	};
}
void test()
{
	My::unique_ptr<int> p(new int);
	My::unique_ptr<int,FREE<int>> p2((int*)malloc(sizeof(int)));//根据不同类型，来对应调用不同的释放方式。
	My::unique_ptr<FILE, FCLOSE>p3(fopen("1.txt", "wb"));
}

shared_ptr
虽然unique_ptr解决了浅拷贝的问题，且基本没有问题。但是应用场景受限，若遇到对于多个资源之间需要共享资源的场景，unique_ptr无法实现。

所以为了解决unique_ptr的问题，在C++11中提出了shared_ptr。此指针不仅解决了浅拷贝的问题，同时可以多个对象之间共享资源。
shared_ptr解决浅拷贝的方式：采用引用计数的方式，就是记录一块资源被多少对象在使用，如果计数为1那么说明只剩最后一个对象在访问资源，则可以释放资源。不为1则不释放。

下面我们来模拟一下shared_ptr：

namespace My
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)//const类型的变量、引用类型的变量、以及包含类类型的对象 这三个变量一般
			//需要在初始化列表的位置进行初始化
			, _pcount(nullptr)
		{
			if (ptr)//若用户给的资源不为空，则记一个数。
				_pcount = new int(1);
		}
		~shared_ptr()
		{
			if (_ptr && (--*_pcount == 0))
			{
				delete _ptr;
				delete _pcount;
			}
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
		{
			if (_ptr)
				++*_pcount;
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (this != &sp)
			{
				if (_ptr&&--*_pcount == 0)//被赋值的对象与旧资源断开，
					//如果被赋值的对象是最后一个使用该块资源的对象，则释放旧的资源与计数。
					//否则，不用释放旧资源，因为还有对象在用此资源。
				{
					delete _ptr;
					delete _pcount;
				}
				_ptr = sp._ptr;//与赋值的对象共享资源和计数
				_pcount = sp._pcount;
				if (_ptr)//如果新资源不为空，计数+1；
					++*_pcount;
			}
			return *this;
		}

		int show__pcount()
		{
			return *_pcount;
		}
	private:
		T* _ptr;
		int* _pcount;
	};
}

以上代码就是shared_ptr的模拟实现。除此外我们还需考虑一点，就是在释放空间时，如果固定用delete来释放资源，则只能管理new出来的资源，对于其他类型资源，无法进行释放操作。这就是代码太局限了。所以我们还需要 定制删除器：使用户可以控制资源具体的释放操作。我们常用仿函数来定制不同的释放方式，然后通过模板参数传入即可。 定制删除器的方法与unique_ptr中相同。

注意：shared_ptr中计数不是线程安全的。因为当有多线程时，很可能会引起计数同时被改写，而造成计数数据不安全。所以就需要进行——加解锁操作，以保证当一个线程对计数进行操作时，其他线程不能对计数进行操作，当此时的操作完时，其他线程才能继续操作。虽然加锁保证计数安全，但不保证用户数据安全。
举例说明：

#include <mutex>//要用加解锁，必须要包含头文件
void Add ()
{
	mutex* _pMutex=new mutex;
	_pMutex->lock();//加锁
	
	...//进行数据操作
	
	_pMutex->unlock();//解锁
}

shared_ptr最大的缺陷：可能会造成循环引用，造成资源泄露。
下面通过一个双向链表的例子来看看什么是循环引用：

struct SlistNode
{
	SlistNode(int data = 0)
		:pre(nullptr)
		, next(nullptr)
		, _data(data)
	{
		cout << "ListNode(int):" << this << endl;
	}
	~SlistNode()
	{
		cout << "~ListNode():" << this << endl;
	}
	shared_ptr<SlistNode> pre;//前一个指针域
	shared_ptr<SlistNode> next;//后一个指针域
	int _data;
};
void test()
{
	shared_ptr<SlistNode> sp1(new SlistNode(10));
	shared_ptr<SlistNode> sp2(new SlistNode(20));
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	sp1->next = sp2;//讲个两个节点连起来
	sp2->pre = sp1;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
}

在这里插入图片描述
那么怎么解决shared_ptr的循环引用问题呢，就用weak_ptr。
weak_ptr：
1.weak_ptr的实现原理和shared_ptr类似——也是用计数的方式。
2.weak_ptr的对象不能独立的管理资源，必须配合shared_ptr来使用。一起解决循环引用的问题

代码如下：

struct ListNode
{
	ListNode(int data = 0)
// 	: pre(nullptr)因为weak_ptr不能独立的管理资源，所以pre、next不需要初始化。
// 	, next(nullptr)
	: _data(data)
	{
		cout << "ListNode(int):" << this << endl;
	}
	~ListNode()
		cout << "~ListNode():" << this << endl;
	//shared_ptr<ListNode> pre;
	//shared_ptr<ListNode> next;
	weak_ptr<ListNode> pre;
	weak_ptr<ListNode> next;
	int _data;
};
//补充：
// weak_ptr<int> sp1;可以编译成功
//weak_ptr<int> sp2(new int);编译失败--原因：weak_ptr不能独立管理资源。
17 C++ 高级之智能指针
a136447572的专栏
08-02 566
Android Ndk 学习笔记（目录） #include <iostream> #include <memory> // 智能指针的头文件引入 using namespace std; class Person{ public: ~Person(){ cout << "Person 析构函数" <<endl ; } }; // 智能指针 void usePerson(){ Person * person1
c++新特性 智能指针和内存管理
qq_62309585的博客
09-08 272
c++ 智能指针 shared_ptr weak_ptr unique_ptr
C++智能指针
冷月
08-17 283
智能指针是用模板实现，创建对象后，对象管理了资源，然后通过析构函数释放掉该资源，以防内存泄漏。auto_ptr（空间管理权限的转移，永远只有一个指针指向动态开辟的空间）#include <iostream> using namespace std;template<class T> class AutoPtr { public: AutoPtr(T* p = NULL) :_
【C++】《C++ 17 入门经典》读书笔记 11 ---- 智能指针：unique_ptr、shared_ptr、weak_ptr
风语留痕
06-29 621
介绍 C++17 中的智能指针：unique_ptr、shared_ptr、weak_ptr。
shellmad-17_C++新特性 智能指针的原理
esjiang的博客
03-10 293
简单的介绍到底什么是智能指针 智能指针: 用起来像指针(注意, 这里用了“像”) 会自己对资源进行释放 自己对资源进行释放 先来写一个简单的例子 class CStudent { public: CStudent() { } void test() { cout << "CStudent" << endl; } private: char* m_pszBuf; int m_nSex; }; 所谓的智能指针是要解决什么问题
c++智能指针最全知识点即面试题目总结
02-27
对于需要面试C++相关岗位的文章，看完这篇文章，如果面试官再问你智能指针，我敢肯定，你一定可以侃侃而谈了~智能指针的面试题，只看这一篇就够了！相信看完这篇文章，妈妈再也不用担心面试官考我智能指针的问题啦...
C++智能指针-unique-ptr智能指针详解.pdf
02-27
《C++智能指针——unique_ptr智能指针详解》 智能指针是C++中用于自动管理动态分配内存的一种工具，它可以确保在适当的时候自动释放内存，从而避免内存泄漏的问题。其中，`unique_ptr`是一种特殊的智能指针，它拥有...
C++智能指针用法详解
12-22
　用智能指针便可以有效缓解这类问题，本文主要讲解参见的智能指针的用法。包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost:: ...
c++智能指针
m0_73686428的博客
04-30 1769
借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：•不需要显式地释放资源。•采用这种方式，对象所需的资源在其生命期内始终保持有效。
c++学习笔记十七(函数指针与智能指针)
qq_41827817的博客
03-15 447
1.auto_ptr 作用：对作用域内的动态分配对象的自动释放 基本类型： #include <iostream> #include <memory> using namespace std; int main(){ int* pn = new int(10); auto_ptr<int> ap(pn); cout << *a...
智能指针的实现
Nemo
03-31 3013
概念  　智能指针本质是对象，但行为却和指针极其相似。 　　是存储指向动态分配（堆）对象指针的类，把一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。 为什么需要智能指针？ 　　比如在异常学习中我们知道，异常很可能会造成资源泄漏，而且由于C++没有垃圾回收机制，就会导致那些申请了的忘记释放的资源的浪费，所以产生智能指针来解决这些问题。 智能指针的使用及原理:   RA...
RALL和智能指针
卖火柴的小男孩
09-10 1209
RAII机制RAII的本质内容是用对象代表资源，把管理资源的任务转化为管理对象的任务，将资源的获取和释放与对象的构造和析构对应起来，从而确保在对象的生存期内资源始终有效，对象销毁时资源一定会被释放。说白了，就是拥有了对象，就拥有了资源，对象在，资源则在。所以，RAII机制是进行资源管理的有力武器，C++程序员依靠RAII写出的代码不仅简洁优雅，而且做到了异常安全。特点在栈语义和操作符重载的支持下，C
C++ 智能指针——简单实现以及循环引用问题
Wu_Qiyou_csdn的博客
08-03 1231
1：智能指针的发展历史？ 2：auto_ptr/scoped_ptr/shared_pr/weak_ptr的设计思想、缺陷？ 3：模拟实现auto_ptr/scoped_ptr/shared_pr/weak_ptr 4：分析循环引用及解决方案。 一.智能指针及其发展史 什么是智能指针呢？        现阶段的智能指针（smart pointer）的一种通用实现技术，是使
RALL 与 智能指针
BlackMonkeyHH的博客
10-19 1527
什么是RALL思想及其应用，智能指针的理解与实现。
C++ RAII机制浅谈
树欲静静风不止止的博客
11-17 3848
RALL机制使得C++程序员能够优雅的释放内存。
RALL资源获取初始化，删除器
dfuw13072的博客
05-29 346
body, table{font-family: 微软雅黑; font-size: 10pt} table{border-collapse: collapse; border: solid gray; border-width: 2px 0 2px 0;} th{border: 1px ...
C++的RALL机制
最新发布
yao_tao11的博客
08-16 738
RAII 是 C++ 中处理资源管理的强大方法，特别适合需要频繁分配和释放资源的场景。通过将资源与对象生命周期绑定，RAII 使代码更具可读性、异常安全性，并有效防止资源泄漏。这一模式在现代 C++ 编程中广泛应用，尤其是在管理内存、文件、线程同步等场景中。
智能指针详解
08-20 1135
一、RALL机制RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。 他的思想是资源分配即初始化，定义一个类来封装资源的的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确释放和初始化RAII要求，资源的有效期与持有资源的对象的⽣命期严
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值