智能指针 auto_ptr、scoped_ptr、shared_ptr、weak_ptr
什么是RAII？
RAII是Resource Acquisition Is Initialization的简称，是C++语言的一种管理资源、避免泄漏的惯用法。
RAII又叫做资源分配即初始化，即：定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。
为什么要使用RAII？
在计算机系统中，资源是数量有限且对系统正常运行具有一定作用的元素。比如：网络套接字、互斥锁、文件句柄和内存等等，它们属于系统资源。由于系统的资源是有限的，所以，我们在编程使用系统资源时，都必须遵循一个步骤：
- 申请资源；
- 使用资源；
- 释放资源。
第一步和第三步缺一不可，因为资源必须要申请才能使用的，使用完成以后，必须要释放，如果不释放的话，就会造成资源泄漏。
什么是智能指针？
所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。它是一个类，有类似指针的功能。
智能指针的实现原理
当类中有指针成员时，一般有两种方式来管理指针成员：
- 一是采用值型的方式管理，每个类对象都保留一份指针指向的对象的拷贝；
- 另一种更优雅的方式是使用智能指针，从而实现指针指向的对象的共享。
智能指针(smart pointer)的通用实现技术是使用引用计数(reference count)。智能指针类将一个计数器与类指向的对象相关联，引用计数跟踪该类有多少个对象的指针指向同一对象。每次创建类的新对象时，初始化指针就将引用计数置为1；当对象作为另一对象的副本而创建时，拷贝构造函数拷贝指针并增加与之相应的引用计数；对一个对象进行赋值时，赋值操作符减少左操作数所指对象的引用计数（如果引用计数为减至0，则删除对象），并增加右操作数所指对象的引用计数；调用析构函数时，析构函数减少引用计数（如果引用计数减至0，则删除基础对象）。
常见的智能指针
包括：std::auto_ptr、boost::scoped_ptr、boost::shared_ptr、boost::scoped_array、boost::shared_array、boost::weak_ptr、boost::intrusive_ptr
Boost库的智能指针（ps:新的C++11标准中已经引入了unique_ptr/shared_ptr/weak_ptr）：
auto_ptr 独占所有权，转移所有权
第一种实现：最开始auto_ptr的成员变量主要有T* _ptr 和 bool _owner,主要实现原理是在构造对象时赋予其管理空间的所有权，在拷贝或赋值中转移空间的所有权，在析构函数中当_owner为true（拥有所有权）时来释放所有权。
template<typename T>
class AutoPtr
{
public:
//构造函数
explicit AutoPtr(T* ptr = NULL)
:_ptr(ptr)
, _owner(true)
{}
//拷贝构造
AutoPtr(AutoPtr<T>& ap) //参数不能写成const的，这里要修改ap对象的成员<br> :_ptr(ap._ptr)
, _owner(true)
{
ap._owner = false; //转让权限
}
//赋值运算符重载
AutoPtr& operator=(AutoPtr<T>& ap)
{
if (this！ = &ap)
{
delete this->_ptr;
this->_ptr = ap._ptr;
// 转让权限
this->_owner = true;
ap._owner = false;
}
return *this;
}
//析构函数
~AutoPtr()
{
// 只删除拥有权限的指针
if (_owner)
{
this->_owner = false;
delete this->_ptr;
}
}
T& operator*()
{
return *(this->_ptr);
}
T* operator->()
{
return this->_ptr;
}
T* AutoPtr<T>::GetStr()
{
return (this->_ptr);
}
protected:
T* _ptr;
bool _owner; //权限拥有者
};
|
|
出现的主要问题：如果拷贝出来的对象比原来的对象先出作用域或先调用析构函数，则原来的对象的_owner虽然为false，但却在访问一块已经释放的空间，原因在于拷贝对象的释放会导致原对象的_ptr指向的内容跟着被释放！
问题体现如下：
ap1将析构的权限给予了ap2,由于ap1._ptr和ap2._ptr指向同一份空间，ap2在出了if作用域之后自动被释放，进而导致ap1._ptr也被释放。
但是在if作用域之外，又对ap1._ptr进行访问，导致程序崩溃，这时候 ap1._ptr已经是一个野指针了，这就造成指针的悬挂的问题！
void Test()
{
AutoPtr<int> ap1(new int(1));
if (true)
{
AutoPtr<int> ap2(ap1);
}
//这里的ap1._ptr已经是一个野指针了，这就造成指针的悬挂的问题
*(ap1.GetStr() )= 10;
}|
|
auto_ptr的第二种实现方法：还是管理空间的所有权转移，但这种实现方法中没有_owner权限拥有者。构造和析构和上述实现方法类似，但拷贝和赋值后直接将_ptr赋为空，禁止其再次访问原来的内存空间,比较简单粗暴。
template<typename T>
class AutoPtr
{
public:
//构造函数
explicit AutoPtr(T* ptr = NULL) //不能写成const T* ptr，否则出现const类型赋值给非const类型的问题
:_ptr(ptr)
{}
//拷贝构造
AutoPtr(AutoPtr<T>& ap)
:_ptr(ap._ptr)
{
ap._ptr=NULL;
}
//赋值运算符重载
AutoPtr& operator=(AutoPtr<T>& ap)
{
if (this！ = &ap)
{
delete this->_ptr;
this->_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
//析构函数
~AutoPtr()
{
// 只删除拥有权限的指针
if (_ptr)
{
delete _ptr;
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* GetStr()
{
return _ptr;
}
protected:
T* _ptr;
};这种实现方式很好的解决了旧版本野指针问题，但是由于它实现了完全的权限转移，所以导致在拷贝构造和赋值之后只有一个指针可以使用，而其他指针都置为NULL,使用很不方便，而且还很容易对NULL指针进行解引用，导致程序崩溃，其危害也是比较大的。
scoped_ptr 独占所有权，防拷贝
scoped_ptr的实现原理是防止对象间的拷贝与赋值。具体实现是将拷贝构造函数和赋值运算符重载函数设置为保护或私有，并且只声明不实现，并将标志设置为保护或私有，防止他人在类外拷贝，简单粗暴，但是也提高了代码的安全性。
template<typename T>
class ScopedPtr
{
public:
ScopedPtr(T* ptr = NULL)
:_ptr(ptr)
{}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* GetStr()
{
return _ptr;
}
//析构函数
~ScopedPtr()
{
if (_ptr!=NULL)
{
delete _ptr;
}
}
protected:
//防拷贝
ScopedPtr(ScopedPtr<T>& ap);
ScopedPtr& operator=(ScopedPtr<T>& ap);
T* _ptr;
};|
| |
scoped_ptr的实现和auto_ptr非常类似，不同的是 scoped_ptr有着更严格的使用限制——不能拷贝，这就意味着scoped_ptr 是不能转换其所有权的。
在一般的情况下，如果不需要对于指针的内容进行拷贝，赋值操作，而只是为了防止内存泄漏的发生，scoped_ptr完全可以胜任。
shared_ptr 共享所有权，引用计数
shared_ptr的实现原理是通过引用计数来实现，拷贝或赋值时将引用计数加1，析构时只有当引用计数减到0才释放空间，否则只需将引用计数减1即可.
（ps:shared_ptr在新的C++11标准中叫做unique_ptr）
template<typename T>
class SharedPtr
{
public:
SharedPtr(T* ptr=NULL)
:_ptr(ptr)
, _refCount(new long(1))
{}
~SharedPtr()
{
_Release();
}
SharedPtr(const SharedPtr<T>& sp)
:_ptr(sp._ptr)
, _refCount(sp._refCount)
{
++(*_refCount);
}
//传统写法
/*SharedPtr<T>& operator=(const SharedPtr<T>& sp)
{
if (this != &sp)
{
this->_Release();
_refCount = sp._refCount;
_ptr = sp._ptr;
++(*_refCount);
}
return *this;
}*/
//现代写法
SharedPtr<T>& operator=(SharedPtr<T> sp)
{
swap(_ptr, sp._ptr);
swap(_refCount, sp._refCount);
return *this;
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* GetPtr()
{
return _ptr;
}
long GetCount()
{
return *_refCount;
}
protected:
void _Release()
{
if (--(*_refCount) == 0)
{
//delete _ptr;
_del(_ptr);
delete _refCount;
}
}
protected:
T* _ptr;
long* _refCount; //引用计数
};|
|
为什么引用计数要设置为指针类型，而不设置成整型或静态变量？
请看这篇文章：http://www.cnblogs.com/Lynn-Zhang/p/5400714.html
有时候看似完美的东西，往往都存在着隐含的缺陷，上面的实现仍旧存在问题！
问题如下：
- 在多线程环境下，引用计数的更新存在安全隐患
- 循环引用问题
- 定制删除器
第一个比较容易理解，我们可以在改变引用计数的时候加上一把互斥锁，防止多线程带来的隐患。
第二个，循环引用问题。我们先来看一段利用标准库的shared_ptr 实现的代码：
#include<iostream>
using namespace std;
#include<memory>
struct Node
{
shared_ptr<Node> _prev;
shared_ptr<Node> _next;
~Node()
{
cout << "delete :" <<this<< endl;
}
};
void TestSharedPtr()
{
shared_ptr<Node> cur(new(Node));
shared_ptr<Node> next(new(Node));
}|
|
cur和next出了作用域，都调用析构函数被释放了。看似正确，但是如果我们加两句代码，问题就出现了：
void TestSharedPtr()
{
shared_ptr<Node> cur(new(Node));
shared_ptr<Node> next(new(Node));
cur->_next = next; // 1
next->_prev = cur; // 2
}|
|
我们发现两个节点都没有被释放！我们来分析一下原因：加了这两句代码后，这两个节点的引用计数都增加了1。出了作用域进行析构时，两个对象均不能释放，因为prev的要释放的前提是next释放，而next的释放又依赖于prev的释放。最后就形成了循环引用，谁都释放不了。
解决方案：
template<class T>
struct Node
{
public:
~Node()
{
cout << "delete:" << this << endl;
}
public:
weak_ptr<Node> _prev;
weak_ptr<Node> _next;
};
void TestWeakPtr()
{
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;
}|
|
因为weak_ptr（弱引用智能指针）会对引用计数会做特殊处理(上述情况不加1)。
第三个，定制删除器。在shared_ptr中只能处理释放new开辟的空间，而对于malloc，以及fopen打开的文件指针不能处理，所以提出了定制删除器，方便释放其他类型的指针，而其实现则是通过仿函数（通过重载operator()）来实现。
template <typename T, class Deleter = Del<T>>
class SharedPtr
{
public:
SharedPtr(T* ptr);
SharedPtr(T* ptr, Deleter del);
SharedPtr(const SharedPtr<T, Deleter>& ap);
~SharedPtr();
//SharedPtr<T, Deleter>& operator=(const SharedPtr<T, Deleter>& ptr);//传统写法
//现代写法
SharedPtr<T, Deleter>& operator=(SharedPtr<T, Deleter> ap);
T& operator*()const;
T* operator->()const;
long GetCount()const;
T* GetPtr()const;
protected:
void _Realease();
protected:
T* _ptr;
long* _pCount;
Deleter _del;
};
template <typename T, class Deleter = Del<T>>
SharedPtr<T, Deleter>::SharedPtr(T* ptr) :_ptr(ptr), _pCount(new long(1))
{}
template <typename T, class Deleter = Del<T>>
SharedPtr<T, Deleter>::SharedPtr(T* ptr, Deleter del) : _ptr(ptr), _pCount(new long(1)), _del(del)
{}
template <typename T, class Deleter = Del<T>>
SharedPtr<T, Deleter>::SharedPtr(const SharedPtr<T, Deleter>& ap) : _ptr(ap._ptr), _pCount(ap._pCount), _del(ap._del)
{
++(*this->_pCount);
}
template <typename T, class Deleter = Del<T>>
SharedPtr<T, Deleter>::~SharedPtr()
{
this->_Realease();
}
//template <typename T, class Deleter = Del<T>>//传统写法
//SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(SharedPtr<T, Deleter> ap)
//{
// if (this->_ptr != ap._ptr)
// {
// this->_Realease();
// this->_ptr = ap._ptr;
// this->_pCount = ap._pCount;
// ++(*this->_pCount);
// }
// return *this;
//}
template <typename T, class Deleter = Del<T>>//现代写法
SharedPtr<T, Deleter>& SharedPtr<T, Deleter>::operator=(SharedPtr<T, Deleter> ap)
{
swap(this->_ptr, ap._ptr);
swap(this->_pCount, ap._pCount);
swap(this->_del, ap._del);
return *this;
}
template <typename T, class Deleter = Del<T>>
T& SharedPtr<T, Deleter>::operator*()const
{
return *(this->_ptr);
}
template <typename T, class Deleter = Del<T>>
T* SharedPtr<T, Deleter>::operator->()const
{
return this->_ptr;
}
template <typename T, class Deleter = Del<T>>
long SharedPtr<T, Deleter>::GetCount()const
{
return *(this->_pCount);
}
template <typename T, class Deleter = Del<T>>
T* SharedPtr<T, Deleter>::GetPtr()const
{
return this->_ptr;
}
template <typename T, class Deleter = Del<T>>
void SharedPtr<T, Deleter>::_Realease()
{
if (--(*this->_pCount) == 0)
{
_del(_ptr);
delete this->_pCount;
}
}
template<typename T>
struct Free
{
void operator()(T* ptr)
{
cout << "Free:"<<ptr<< endl;
free(ptr);
}
};
template<typename T>
struct Fclose
{
void operator()(T* ptr)
{
cout << "Fclose:" << ptr << endl;
fclose(ptr);
}
};
template<typename T>
struct Del
{
void operator()(T* ptr)
{
cout << "Delete:" << ptr << endl;
delete(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);
SharedPtr<int> sp3(new int(1));
}|
|
总结：
auto_ptr 管理权的转移 ->不建议使用
scopd_ptr ( unique_ptr ) 防拷贝 ->简单粗暴
shared_ptr 引用计数 ->增减引用计数，直到对象的引用计数为0时再释放
scoped_array 和 shared_array 管理对象数组， 由于scopd_ptr 和 scoped_array、shared_ptr 和 shared_array 的实现都比较类似，这里不再赘述。需要注意的是这两种机制都重载了operator[] .
week_ptr 弱指针 ->辅助shared_ptr解决循环引用的问题。
转载必须注明作者和出处：
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
