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、付费专栏及课程。

余额充值