在C++中,我们经常会用到动态开辟内存,需要我们自己维护,在出函数作用域之前,必须将管理的内存释放掉,否则就会造成内存泄漏,即使我们十分小心,但总有可能出错,因此便有了智能指针。
RAII:资源分配即初始化:定义一个类来封装资源的分配和释放,在构造函数完成资源的分配和初始化,在析构函数完成资源的清理,可以保证资源的正确初始化和释放。
1. auto_ptr,auto_ptr的实现机制是资源的转移,在拷贝构造函数和运算符重载函数中将当前对象的指针置为空,以实现资源的转移
template <class T>
class AutoPtr
{
public:
AutoPtr(T* ptr = NULL)
: _ptr(ptr)
{}
~AutoPtr()
{
if (_ptr)
{
delete _ptr;
_ptr = NULL;
}
}
T& operator*()
{
return (*_ptr);
}
T* operator->()
{
return _ptr;
}
AutoPtr(AutoPtr& ap)
: _ptr(ap._ptr)
{
ap._ptr = NULL;
}
AutoPtr& operator=(AutoPtr& ap)
{
if (this != &ap)
{
if (_ptr)
delete _ptr;
_ptr = ap._ptr;
ap._ptr = NULL;
}
return *this;
}
private:
T* _ptr;
};
它的缺陷是:当我们用一个对象去构造另一个对象时,原对象由于被置为NULL,则不能再使用了。
我们可以设置增加一个变量,当前对象如果为该资源的拥有者,则可以释放空间,否则,它将只有使用权。
template <class T>
class AutoPtr
{
public:
AutoPtr(T* ptr = NULL)
: _ptr(ptr)
, _owner(true)
{
if (NULL == _ptr)
_owner = false;
}
AutoPtr(const AutoPtr& ap)
: _ptr(ap._ptr)
, _owner(ap._owner)
{
ap._owner = false;
}
AutoPtr& operator=(const AutoPtr& ap)
{
if (this != &ap)
{
if (_ptr)
delete _ptr;
_ptr = ap._ptr;
_owner = ap._owner;
ap._owner = false;
}
return *this;
}
~AutoPtr()
{
if (_ptr && _owner == true)
{
delete _ptr;
_owner = false;
_ptr = NULL;
}
}
private:
T* _ptr;
mutable bool _owner;
};
它的缺陷是:如果我们在一个if的作用域中用对象ap1创建了ap2,那出了作用域,ap2被释放,ap1中的_ptr变成了野指针,无法再使用。因此,C++11建议不要使用auto_ptr。
2. scoped_ptr,这是boost库中的智能指针,它的实现机制是防拷贝,将拷贝构造函数和赋值运算符重载只声明而不定义,并设为私有成员。在C++标准库中unique_ptr与它的实现机制类似。
template<class T>
class ScopedPtr
{
public:
ScopedPtr(T* ptr = NULL)
: _ptr(ptr)
{}
~ScopedPtr()
{
if (_ptr)
{
delete _ptr;
_ptr = NULL;
}
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
private://防拷贝,将声明设为私有而不定义
ScopedPtr(const ScopedPtr& sp);
ScopedPtr& operator=(const ScopedPtr sp);
private:
T* _ptr;
};
3. shared_ptr,它的实现原理类似于string类中的引用计数。拷贝一次,引用计数增加1,当引用计数为0时2,释放空间。
template<class T>
class SharedPtr
{
public:
SharedPtr(T* ptr = NULL)
: _ptr(ptr)
, _pCount(new int(0))
{
if (_ptr)
*_pCount = 1;
}
SharedPtr(const SharedPtr& sp)
: _ptr(sp._ptr)
, _pCount(sp._pCount)
{
(*_pCount)++;
}
SharedPtr& operator=(const SharedPtr& sp)
{
if (this != &sp)
{
if (_pCount && --(*_pCount) == 0)
{
delete _ptr;
delete _pCount;
}
_ptr = sp._ptr;
_pCount = sp._pCount;
if (*_pCount)
(*_pCount)++;
}
return *this;
}
~SharedPtr()
{
if (_ptr && --(*_pCount))
{
delete _ptr;
_ptr = NULL;
delete _pCount;
_pConut=NULL;
}
}
T* operator->()
{
return _ptr;
}
T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
int* _pCount;
};
weak_ptr与shared_ptr搭配使用,shared_ptr中存在着循环引用的问题。例如:
template<class T>
struct Node
{
Node(const T& data)
: _data(data)
{
cout << "Node()" << this << endl;
}
T _data;
weak_ptr<Node<T>> _pNext;
weak_ptr<Node<T>> _pPre;
~Node()
{
cout << "~Node()" << this << endl;
}
};
int main()
{
shared_ptr<Node<int>> sp1(new Node<int>(10));
shared_ptr<Node<int>> sp2(new Node<int>(20));
cout << sp1.use_count() << endl;
cout << sp2.use_count() << endl;
sp1->_pNext = sp2;
sp2->_pPre = sp1;
cout << sp1.use_count() << endl;
cout << sp2.use_count() << endl;
return 0;
}
如果只是shared_ptr,由于sp1的next指向了sp2,sp2的pre指向了sp1,因此sp1和sp2的count为2,无法完成析构。当使用了weak_ptr时,引用计数count没有增加,增加的是weak计数。