C++11新增特性：智能指针（RAII）

已于 2024-12-23 21:51:00 修改
阅读量1.7k 收藏 24
点赞数 44
CC 4.0 BY-SA版权
分类专栏： C++经典收录 文章标签： c++ 智能指针 RAII 引用计数 shared_ptr unique_ptr boost
于 2024-09-22 10:35:34 首次发布
是小宇吖~
本文链接：https://blog.youkuaiyun.com/Zhenyu_Coder/article/details/142430796

C++11新增特性：智能指针（RAII）

一、RAII

 RAII（Resource Acquisition Is Initialization）,资源获得即初始化，是一种利用对象的生命周期对资源进行管理的简单技术！！对象在构造时获得资源，然后控制着对资源的访问，使之在对象的生命周期内始终有效；对象在析构时对资源进行释放。通过RAII的思想对资源进行管理有两大好处：

  • 无需显示释放资源。比如在程序抛异常时，对象析构时对自动释放资源，大大降低了内存泄漏的风险！
  • 对象所需的资源在其生命期内始终保持有效。

二、智能指针原理

 智能指针是一种通过RAII的思想对动态分配的内资源进行管理，并且具备指针的行为，支持解引用和通过->去访问其指向资源的内容！！在C++的发展史中，一个出现了4种智能指针，依次为auto_ptr、unique_ptr、shared_ptr、weak_ptr（weak_ptr不符合RAII思想，用于对shared_ptr的补贴）

  • 接下来所有的指针指针首字母大写，防止各位测试和C++库中对应智能指针冲突！

1）、auto_ptr

 在C++98中，提供了名为auto_ptr的智能指针。auto_ptr的原理为：管理权转移！通过auto_ptr对动态分配内存资源进行管理，但如果在使用过程中发生拷贝、赋值等行为时，直接将对资源的管理权转移给新对象！

 emmm…，但很多公司明确禁止使用auto_ptr。原理在于auto_ptr会导致对象悬空！
【auto_ptr】实现：

template <class T>
class Auto_ptr
{
public:
	Auto_ptr(T* ptr = nullptr) :_ptr(ptr)
	{}
	~Auto_ptr()
	{
		if(_ptr)
			delete _ptr;
		cout << "~Auto_ptr()" << endl; // for test
	}
public:
	Auto_ptr(Auto_ptr& p)
		:_ptr(p._ptr)
	{
		p._ptr = nullptr;
	}
	Auto_ptr<T>& operator=(Auto_ptr<T>& ap)
	{
		if (this != &ap)
		{
			delete _ptr;
			_ptr = ap._ptr;
			ap._ptr = nullptr;
		}
		return *this;
	}
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
};

2)、unique_ptr

 在C++11中，新增名为unique_ptr的智能指针。和auto_ptr不同的是， unique_ptr直接简单粗暴防拷贝！！

【unique_ptr实现】：

template <class T>
	class Unique_ptr
	{
	public:
		Unique_ptr(T* ptr = nullptr) :_ptr(ptr)
		{}
		~Unique_ptr()
		{
			delete _ptr;
			cout << "~Unique_ptr()" << endl; // for test
		}
		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
	public: 
		// C++98实现方式： 只声明不实现 同时访问权限设置为私有
		Unique_ptr(const Unique_ptr<T>& up) = delete;
		Unique_ptr<T>& operator=(const Unique_ptr<T>& up) = delete;
	private:
		T* _ptr;
	};

3)、shared_ptr

 在C++11还提供了更为靠谱的shared_ptr智能指针，并且支持拷贝行为！！

 shared_ptr通过引用计数的方式实现多个对象间资源共享！每一个shared_ptr对象内部会维护一把计数器，用来记录该资源被几个对象共享。在shared_ptr对象构造时，引用计数加1；析构时，引用计数减1。但需要主要的时，析构时只有引用计数减为0，也意味着自己是这块资源的最后使用者，此时才能对所管理的资源进行释放！！

 但对象构造和析构时都需要会引用计数进行操作。此时多执行并发访问时，可能会导致数据不一致问题！所以我们需要对计数器进行加锁！！

【shared_ptr实现】：由于在拷贝构造、赋值重载以及析构时，都会设计到引用计数++和–，以及引用计数–需要判断释放需要将资源进行释放。所以我们将两者行为单独实现成AddRef() 增加引用计数；Release()减少引用计数（内部会判断是否需要将资源进行释放）（其他详见代码）

template <class T>
class Shared_ptr
{
public:
	Shared_ptr(T * ptr = nullptr)
		:_ptr(ptr), _Pcount(new std::atomic<int>(1))
	{}

	Shared_ptr(const Shared_ptr<T>& sp)
		:_ptr(sp._ptr), _Pcount(sp._Pcount)
	{
		(*_Pcount)++;
	}

	Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr) // 防止直接或间接和自己赋值，指向同一块空间
		{
			release(); // 在赋值前，将自身引用计数--
			_ptr = sp._ptr;
			_Pcount = sp._Pcount;
			(*_Pcount)++;
			return *this;
		}
	}

	int use_count() const { return _Pcount->load(); }
	T* get() const  { return _ptr; } // const 防止权限放大
	T* operator->() { return _ptr; }
	T& operator*() { return *_ptr; }


	~Shared_ptr()
	{
		release();
	}
private:
	void release()
	{
		if (--(*_Pcount) == 0)
		{
			delete _ptr;
			delete _Pcount;
		}
	}
private:
	T* _ptr;
	std::atomic<int>* _Pcount; // 不能设置为静态（static int count）
};
  1. 引用计数不能为const int。原因在于每次析构时，当前对象析构，其他对象的引用计数不会–。会导致内存泄漏问题！
  2. 引用计数不能为static int。静态成员所有类对象共享该类实例化的成员。
  3. shared_ptr本事是线程安全的，但shared_ptr所指向的资源不是线程安全的

增加定制删除器

template <class T>
class Shared_ptr
{
public:
	Shared_ptr(T * ptr = nullptr)
		:_ptr(ptr), _Pcount(new std::atomic<int>(1))
	{}

	Shared_ptr(const Shared_ptr<T>& sp)
		:_ptr(sp._ptr), _Pcount(sp._Pcount)
	{
		(*_Pcount)++;
	}

	template <class D>
	Shared_ptr(const Shared_ptr<T>& sp, D del)
		:_ptr(sp._ptr), _Pcount(sp._Pcount), _del(del)
	{
		(*_Pcount)++;
	}
	Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr) // 防止直接或间接和自己赋值，指向同一块空间
		{
			release(); // 在赋值前，将自身引用计数--
			_ptr = sp._ptr;
			_Pcount = sp._Pcount;
			(*_Pcount)++;
			return *this;
		}
	}

	int use_count() const { return _Pcount->load(); }
	T* get() const  { return _ptr; } // const 防止权限放大
	T* operator->() { return _ptr; }
	T& operator*() { return *_ptr; }


	~Shared_ptr()
	{
		release();
	}
private:
	void release()
	{
		if (--(*_Pcount) == 0)
		{
			_del(_ptr);
			delete _Pcount;
		}
	}
private:
	T* _ptr;
	std::atomic<int>* _Pcount; // 不能设置为静态（static int count）
	std::function<void(T*)> _del = [](T* ptr) { delete ptr; };
};

4）、weak_ptr

  1 ( weak_ptr由来和用途

 shared_ptr已经非常完美了，但还是存在一些问题。下面是一个链表结构，我们将两块资源分别交给智能指针shared_ptr进行管理，然后在每一块资源中，还存在一个shared_ptr智能指针指向对方资源。此时就会导致循环引用的问题！而weak_ptr就是对shared_ptr进行补贴，解决循环引用的问题！！

  .2 ( 循环引用问题

  两个或多个 shared_ptr 对象相互持有对方的引用，形成一个闭环，导致它们之间的引用计数永远无法归零，从而造成内存泄漏。
 下面这段代码就是一个典型的循环引用l例子！！

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode()
	{
		cout << "~ListNode()" << endl; // for debug
	}
};

int main()
{
	shared_ptr<ListNode> n1 = new ListNode;
	shared_ptr<ListNode> n2 = new ListNode;

	n1->_prev = n2;
	n2->_next = n1;
	return 0;
}

 n1和n2首先会指向给自的资源，此时引用计数为1。但n1内部_prev智能指针和n2指向同一块资源，所以n2的引用计数更新为2。同理，n1的引用计数也更新为2！！

 
 此时，当变量n1和n2分别出作用域时， node1和node2析构，引用计数减到1。
 但是_next还指向下一个节点。但是_prev还指向上一个节点。 也就是说n2->_next析构了，n1就释放了; n1->_prev析构了，node2就释放了！
 但是_next属于n2的成员，n1释放了，_next才会析构，而n2由_prev管理，_prev属于n1成员，此时就发生了循环引用，谁也不会释放。内存泄漏！！
在这里插入图片描述

  .3 ( weak_ptr

 所以C++11增加了weak_ptr。和传统指针不同的是，weak_ptr不符合RAII，不参与引用计数，仅是对 shared_ptr 所管理对象的一个非拥有性引用，但可以像指针一样使用！！但如果Shared_ptr指向的空间释放，可能会导致野指针。所以实际Weak_ptr会有一个use_count观察Shared_ptr引用计数

template <class T>
class Shared_ptr
{
public:
	Shared_ptr(T * ptr = nullptr)
		:_ptr(ptr), _Pcount(new std::atomic<int>(1))
	{}

	Shared_ptr(const Shared_ptr<T>& sp)
		:_ptr(sp._ptr), _Pcount(sp._Pcount)
	{
		(*_Pcount)++;
	}

	template <class D>
	Shared_ptr(const Shared_ptr<T>& sp, D del)
		:_ptr(sp._ptr), _Pcount(sp._Pcount), _del(del)
	{
		(*_Pcount)++;
	}
	Shared_ptr<T>& operator=(const Shared_ptr<T>& sp)
	{
		if (_ptr != sp._ptr) // 防止直接或间接和自己赋值，指向同一块空间
		{
			release(); // 在赋值前，将自身引用计数--
			_ptr = sp._ptr;
			_Pcount = sp._Pcount;
			(*_Pcount)++;
			return *this;
		}
	}

	int use_count() const { return _Pcount->load(); }
	T* get() const  { return _ptr; } // const 防止权限放大
	T* operator->() { return _ptr; }
	T& operator*() { return *_ptr; }


	~Shared_ptr()
	{
		release();
	}
private:
	void release()
	{
		if (--(*_Pcount) == 0)
		{
			_del(_ptr);
			delete _Pcount;
		}
	}
private:
	T* _ptr;
	std::atomic<int>* _Pcount; // 不能设置为静态（static int count）
	std::function<void(T*)> _del = [](T* ptr) { delete ptr; };
};



// 不参与Shared_ptr的引用计数，不支持RAII。
// 但如果Shared_ptr指向的空间释放，可能会导致野指针。
// 所以实际Weak_ptr会有一个use_count观察Shared_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; }
private:
	T* _ptr;
};

【使用用例】：

struct ListNode
{
	int _data;
	Weak_ptr<ListNode> _prev;
	Weak_ptr<ListNode> _next;
};

int main()
{
	Shared_ptr<ListNode> n1 = new ListNode;
	Shared_ptr<ListNode> n2 = new ListNode;
	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;

	n1->_next = n2;
	n2->_prev = n1;

	Shared_ptr<ListNode> n3(new ListNode[10], [](ListNode* ptr) {delete[] ptr; });

	cout << n1.use_count() << endl;
	cout << n2.use_count() << endl;


	return 0;
}

三、C++11和boost中智能指针的关系

  1. 在C++98时，C++出现了第一个智能指针auto_ptr。
  2. 在99年时，boost成立。并且在C++98和C++11之间，boost给出了更为实用的智能指针：scoped_ptr和shared_ptr和weak_ptr。
  3. C++ TR1，引入了shared_ptr等。不过注意的是TR1并不是标准版
  4. C++ 11，引入了unique_ptr和shared_ptr和weak_ptr。其中unique_ptr对应boost中的scoped_ptr，并且这些智能指针的实现原理是参照boost中的相关智能指针实现的！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小白debug~

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

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

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

打赏作者

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

抵扣说明：

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

余额充值