c++智能指针的不断演化

时间  2020-01-25
标签 c++ 智能 指针 不断 演化 栏目 C&C++ 繁體版
原文   原文链接

RAII资源分配即初始化，定义一个类来封装资源的分配和释放，在构造 函数完成资源的分配和初始化，在析构函数完成资源的清理，能够保证资源的正确初始化和释放。 
c++

智能指针的引入：
安全

因为return ,throw等关键字的存在，致使顺序执行流的错乱，不断的进行跳转，使开辟的空间ide

看似被释放，而实际上致使内存的泄露。函数

例如如下两个例子：
测试

void Test1()
{
	int *p1 = new int(1);
	if (1)
	{
		return;
	}
	delete p1;
}

void DoSomeThing() 
{     //...     
	throw 2 ;
	//... 
} 
void Test2 () 
{     
	int* p1 = new int(2);   
	//...    
	try 
	{          
		DoSomeThing();  
	}     
	catch(...)    
	{          
		//delete p1 ;         
		throw;  
	}     
	//...     
	delete p1 ;
}

以上两个例子，看似new与delete结合使用，可是实际上已经致使内存的泄露，为了解决以上问题，就须要在写此类代码时须要多加当心，可是对于大量的代码开发，想要注意就很难了。this

因而乎就引入了智能指针：spa

所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。3d

c++库函数中的智能指针为（auto_ptr,unique_ptr,shared_ptr）；指针

Boost库函数中的智能指针为（auto_ptr,scoped_ptr,shared_ptr）。对象


接下来就一块儿来了解一下智能指针的发展历史。

一、在vc6.0以前的版本中auto_ptr的模拟实现方式

template<class T>
class OldAutoPtr
{
public:
	OldAutoPtr(T *ptr)
		:_ptr(ptr)
		, _owner(true)
	{}

	//拷贝构造
	OldAutoPtr(OldAutoPtr& ap)
		:_ptr(ap._ptr)
		,_owner(ap._owner)
	{
		ap._owner = false;//权限的转让
	}

	//运算符重载
	OldAutoPtr& operator=(OldAutoPtr& ap)
	{
		if (ap._ptr != _ptr)//自赋值和指向同一份空间
		{
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = ap._ptr;
			_owner = ap._owner;//权限的转让
			ap._owner = false;
		}
		return *this;
	}

	//析构函数
	~OldAutoPtr()
	{
		if (_owner)//只删除拥有权限的指针
		{
			delete _ptr;
		}
	}

public:

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

	T* operator ->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	bool _owner;//权限拥有者
};


评价：

看似最第一版本的auto_ptr已经很接近了原声指针的使用，多个指针均可以指向一份空间，并且释放的同时不会致使同一份空间的屡次释放。可是在下面的情境中却发生了致命的危害：


void TestOldAutoPtr()
{
	OldAutoPtr<int> ap1(new int(1));
	if (true)
	{
		OldAutoPtr<int> ap2(ap1);
		//OldAutoPtr<int> ap3(new int(2));
		//ap3 = ap2;
	}
	//ap1将析构的权限给予了ap2，ap1，ap2指向同一份空间，ap2在出了if做用域以后ap2对象释放，进而致使ap1也被释放。
	//可是在if做用域以外，又对ap1(ap2)指向的空间进行简引用，致使程序崩溃，若是不使用的话则会形成指针的悬挂（野指针）。
	*ap1 = 10;
}

针对以上的情况，在以后的版本中对auto_ptr进行了彻底的权限转移，转移以后该指针不能使用。


二、如今的版本auto_ptr的实现

template<typename T>
class AutoPtr
{
public:
	AutoPtr(T* ptr)
		:_ptr(ptr)
	{}
	AutoPtr(AutoPtr<T>& ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = NULL;//权限转移
	}

	AutoPtr<T>& operator=(AutoPtr<T> & ap)
	{
		if (this != &ap)//自赋值
		{
			if (_ptr)
			{
				delete _ptr;
			}
			_ptr = ap._ptr;
			ap._ptr = NULL;//权限转移
		}
		return *this;
	}

	~AutoPtr()
	{
		if (_ptr != NULL)
		{
			delete _ptr;
			_ptr = NULL;
		}
	}
public:
	T& operator * ()//没有参数
	{
		return *_ptr;
	}

	T* operator->()//没有参数
	{
		return _ptr;
	}
private:
	T* _ptr;
};

评价：

这种实现方式很好的解决了old的版本特殊场景的野指针问题，可是它与原生指针的差异更大，因为实现了彻底的权限转移，因此致使在拷贝构造和赋值以后只有一个指针可使用，而其余指针都置为NULL,使用很不方便，并且还很容易致使对于NULL指针的截引用，致使程序崩溃，其危害也是比较大的。


三、针对以上的问题，在Boost库中引入了简单粗暴的解决方法scoped_ptr，直接不容许其拷贝构造和赋值（ps:新的C++11标准中叫作unique_ptr）

解决办法：将赋值和拷贝构造函数只声明，不实现，切记，将其声明为protected或者private以避免在类的外部对其进行破环性处理，同时也是提升了代码的安全性。

template<typename T>
class ScopedPtr
{
	
public:
	ScopedPtr(T* ptr)
		:_ptr(ptr)
	{}
	~ScopedPtr()
	{
		if (_ptr != NULL)
		{
			delete _ptr;
		}
	}
protected://将其声明为protected或者private不能声明为public
	ScopedPtr(ScopedPtr<T>& sp);
	ScopedPtr<T>operator=(ScopedPtr<T>&sp);
public:
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T *_ptr;
};

评价：

在通常的状况下，若是不须要对于指针的内容进行拷贝，赋值操做，而只是为了防止内存泄漏的发生，该只能指针彻底能够知足需求。


四、容许拷贝构造和赋值的shared_ptr模拟实现

解决办法：

经过为每一个空间多开辟4个字节作为引用计数器，在拷贝构造、赋值、析构时用计数器来解决。

template<typename T>
class SharedPtr
{
public:
	SharedPtr(T* ptr)
		:_ptr(ptr)
		, _pCount(new int(1))
	{}

	SharedPtr(const SharedPtr<T>& sp)
	{
		_ptr = sp._ptr;
		_pCount = sp._pCount;
		(*_pCount)++;
	}

	SharedPtr<T>operator=(SharedPtr<T> sp)
	{
		swap(_ptr, sp._ptr);
		swap(_pCount, sp._pCount);
		return *this;
	}

	~SharedPtr()
	{
		_Realse();
	}
public:
	void _Realse()
	{
		if (--(*_pCount) == 0)
		{
			delete _ptr;
			delete _pCount;
		}
	}

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

评价：

简化版智能指针SharedPtr看起来不错，可是实际上存在如下问题： 

1）循环引用 

2）定置删除器

 

循环引用

wKioL1cCPcDRtdC_AABA24YFxww003.png

template<class T>
struct Node
{
public:
	~Node()
	{
		cout << "delete:" << this << endl;
	}
public:
	shared_ptr<Node> _prev;
	shared_ptr<Node> _next;
	/*weak_ptr<Node> _prev;
	weak_ptr<Node> _next;*/
};

void test_round()//循环引用
{
	shared_ptr<Node> cur(new Node());
	shared_ptr<Node> next(new Node());

	cout << "链接前：" << endl;
	cout << "cur:" << cur.use_count() << endl;
	cout << "next:" << next.use_count() << endl;

	cur->_next = next;
	next->_prev = cur;

	cout << "链接后：" << endl;
	cout << "cur:" << cur.use_count() << endl;
	cout << "next:" << next.use_count() << endl;


	/*shared_ptr<Node> cur(new Node());
	weak_ptr<Node> wp1(cur);*/
}

wKioL1cCfcGxU20qAAAFxvuL2sA712.png

解决办法：

使用一个弱引用智能指针(weak_ptr)来打破循环引用（weak_ptr不增长引用计数）

template<class T>
struct Node
{
public:
	~Node()
	{
		cout << "delete:" << this << endl;
	}
public:
	//shared_ptr<Node> _prev;
	//shared_ptr<Node> _next;
	weak_ptr<Node> _prev;
	weak_ptr<Node> _next;
};

void test_round()//循环引用
{
	shared_ptr<Node> cur(new Node());
	shared_ptr<Node> next(new Node());

	cout << "链接前：" << endl;
	cout << "cur:" << cur.use_count() << endl;
	cout << "next:" << next.use_count() << endl;

	cur->_next = next;
	next->_prev = cur;

	cout << "链接后：" << endl;
	cout << "cur:" << cur.use_count() << endl;
	cout << "next:" << next.use_count() << endl;


	/*shared_ptr<Node> cur(new Node());
	weak_ptr<Node> wp1(cur);*/
}

wKiom1cCfVHCUHqMAAAIDoEfde0019.png


定置删除器

在shared_ptr中只能处理释放new开辟的空间，而对于malloc，以及fopen打开的文件指针不能处理，为了可以全面的处理各类各样的指针，因此提出了定制删除器，而其实现则是经过仿函数（经过对（）运算符的重载）来实现。

1）模拟实现的解决

template<typename T,typename D>
class SharedPtr
{
public:
	SharedPtr(T* ptr)
		:_ptr(ptr)
		, _pCount(new int(1))
	{}

	SharedPtr(T* ptr, D del)
		:_ptr(ptr)
		, _pCount(new int(1))
		, _del(del)
	{}

	SharedPtr(const SharedPtr<T, D>& sp)
	{
		_ptr = sp._ptr;
		_pCount = sp._pCount;
		(*_pCount)++;
	}

	SharedPtr<T, D>operator=(SharedPtr<T, D> sp)
	{
		swap(_ptr, sp._ptr);
		swap(_pCount, sp._pCount);
		return *this;
	}
	~SharedPtr()
	{
		_Realse();
	}
public:
	void _Realse()
	{
		if (--(*_pCount) == 0)
		{
			_del(_ptr);
			delete _pCount;
		}
	}
	
public:
	T& operator*()
	{
		return *_ptr;
	}
	T* operator->()
	{
		return _ptr;
	}
private:
	T* _ptr;
	int* _pCount;
	D _del;
};

template<typename T>
struct DeafaultDel
{
	void operator()(T* ptr)
	{
		cout << "DeafaultDel:" << ptr << endl;
	}
};

template<typename T>
struct Free
{
	void operator()(T*ptr)
	{
		cout << "Free:" << ptr << endl;
	}
};

template<typename T>
struct Fclose
{
	void operator()(T* ptr)
	{
		cout << "Fclose:" << ptr << endl;
		fclose(ptr);
	}
};
//测试代码
void TestDelete()
{
	int *p1 = (int*)malloc(sizeof(int));
	SharedPtr<int,Free<int>> sp1(p1);
	
	FILE* p2 = fopen("test.txt", "r");
	SharedPtr<FILE, Fclose<FILE>> sp2(p2);
}

测试结果

wKioL1cCfmySWF2nAAADpZe4LQ4745.png

2）系统shared_ptr的解决

struct Free
{
	void operator()(void * ptr)
	{
		cout << "Free:" << ptr << endl;
		free(ptr);	
	}
};

struct Fclose
{
	void operator ()(FILE* ptr)
	{
		cout << "Fclose" << ptr << endl;
		fclose(ptr);
	}
};
//测试代码
void test_shared_ptr_delete()
{
	int *p1 = (int*)malloc(sizeof(int));
	shared_ptr<int> sp1(p1,Free());

	FILE* p2 = fopen("test.txt", "r");
	shared_ptr<FILE> sp2(p2,Fclose());//崩溃

}

测试结果

wKiom1cCfguhS-0xAAAGXIJd9SM602.png


总结：

一、若是须要使用智能指针的话，scoped_ptr彻底能够胜任。在很是特殊的状况下，例如对STL容器对象，应该只使用shared_ptr，任何状况下都不要使用auto_ptr.

二、使用时尽可能局部化，由于其是经过调用其析构函数来实现资源的回收。 

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程