引言：
由于 C++ 语言没有自动内存回收机制，程序员每次 new 出来的内存都要手动 delete。程序员忘记 delete，流程太复杂，最终导致没有 delete，异常导致程序过早退出，没有执行 delete 的情况并不罕见。
RAII(Resource Acquisition Is Initialization)
资源分配即初始化，定义一个类来封装资源的分配和释放，在构造函数完成资源的分配和初始化，在析构函数完成资源的清理，可以保证资源的正确初始化和释放。
所谓智能指针就是智能/自动化的管理指针所指向的动态资源的释放。
STL--auto_ptr
Boost库的智能指针（ps:新的C++11标准中已经引入了unique_ptr/shared_ptr/weak_ptr）
在这里，对于aut_optr，scoped_ptr , shared_ptr 进行剖析
一. aut_optr
std::auto_ptr 属于 STL，当然在 namespace std 中，包含头文件 #include<memory> 便可以使用。std::auto_ptr 能够方便的管理单个堆内存对象。为了解决单个对象被重复释放多次的情况，我们使用的aut_optr的目的就是转移权限，顾名思义就是说再拷贝构造新的对象时，由于此时有两个对象指向同一块空间，所以将原来的指针赋NULL，然后将这块空间的所有权交给新的对象指针。
对应代码：<AutoPtr>
#include<iostream>
using namespace std;
template<class T>
class AutoPtr
{
public:
AutoPtr(T* ptr)
:_ptr(ptr)
{}
AutoPtr()
:_ptr(NULL)
{}
AutoPtr<T>(AutoPtr<T>& ap) //权限转移
: _ptr(ap._ptr)
{
ap._ptr = NULL;
}
AutoPtr<T>& operator=(AutoPtr<T>& ap)
{
if (&ap != this)
{
delete _ptr;
_ptr = ap._ptr;
ap._ptr = NULL; //权限转移
}
return *this;
}
~AutoPtr()
{
if (_ptr)
{
delete _ptr;
_ptr = NULL;
}
}
T& operator*()
{
return *_ptr;
}
private:
T* _ptr;
};
void Test()
{
AutoPtr<int> ap1(new int(2));
AutoPtr<int> ap2 = ap1;
AutoPtr<int> ap3(new int(3));
ap3 = ap1;
}
int main()
{
Test();
return 0;
}
虽然表面上解决了重复释放的问题，但是却存在一个很大问题，请看右图：
（先忽略 s 的存在）
若有s2对象，指向自己的一块空间，现在要拷贝构造一个s3对象，那么顺应上面的代码，s2会被置NULL,而这块空间重归s3所管理。
如果考虑到这块空间已经有多个指针指向，即s和s2,那么再拷贝构造s3时，s2被置空，此时，s变成垂悬指针。这就是一个打的问题所在！
二. scoped_ptr
实用的智能指针，思想就是防拷贝，在大多时候用不到拷贝构造和赋值运算符重载，那么我们做的就是写出构造函数和析构函数，拷贝构造和赋值运算符重载只声明不定义。这里有几点要说明：
<1>在代码中，将拷贝构造和赋值运算符重载设置成保护或者私有的，为什么？世界之大，总有些人想害朕。。话归主题，原因是防止有坏人在外面修改，倘若被修改也不会调用修改的，因为无法访问得到。
<2>为什么要声明拷贝构造和赋值函数，原因是如果不声明，编译器会调用自己默认的构造和赋值函数，那么防拷贝就无从谈起。
代码如下：<ScopedPtr>
#include<iostream>
using namespace std;
template<class T>
class ScopedPtr
{
public:
ScopedPtr(T* ptr)
:_ptr(ptr)
{}
Scoped()
:_ptr(NULL)
{}
~ScopedPtr()
{
if (_ptr)
{
delete _ptr;
_ptr = NULL;
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
T* GetPtr()
{
return _ptr;
}
protected:
ScopedPtr<T>(const ScopedPtr<T>& sp);// 只声明不定义，防拷贝
ScopedPtr<T>& operator = (const ScopedPtr<T>& sp);
private:
T* _ptr;
};
void Test()
{
ScopedPtr<int> sp1(new int(2));
ScopedPtr<int> sp2 = sp1;
ScopedPtr<int> sp3(new int(3));
sp3 = sp1;
}
int main()
{
Test();
return 0;
}
auto_ptr和scopedptr的取舍：
boost::scoped_ptr 用于确保动态分配的对象能够被正确地删除。scoped_ptr 有着与std::auto_ptr类似的特性，而最大的区别在于它不能转让所有权而auto_ptr可以。事实上，scoped_ptr永远不能被复制或被赋值！scoped_ptr 拥有它所指向的资源的所有权，并永远不会放弃这个所有权。scoped_ptr的这种特性提升了我们的代码的表现，我们可以根据需要选择最合适的智能指针(scoped_ptr 或 auto_ptr)。要决定使用std::auto_ptr还是boost::scoped_ptr, 就要考虑转移所有权是不是你想要的智能指针的一个特性。如果不是，就用scoped_ptr. 它是一种轻量级的智能指针；使用它不会使你的程序变大或变慢。它只会让你的代码更安全，更好维护。
三. sharede_ptr
在上面我们看到 boost::scoped_ptr 独享所有权，不允许赋值、拷贝，boost::shared_ptr 是专门用于共享所有权的，由于要共享所有权，其在内部使用了引用计数。boost::shared_ptr 也是用于管理单个堆内存对象的。
这个智能指针解决了auto_ptr独占的问题，采用引用计数的方法，一旦最后一个这样的指针被销毁，也就是一旦某个对象的引用计数变为0，这个对象会被自动删除。这在非环形数据结构中防止资源泄露很有帮助。
用法：删除共用对象
对应代码：<SharedPtr>
#include<iostream>
using namespace std;
template<class T>
class SharedPtr
{
public:
SharedPtr(T* ptr)
:_ptr(ptr)
, _pCount(new long(1))
{}
SharedPtr()
:_ptr(NULL)
, _pCount(new long(1))
{}
SharedPtr<T>(const SharedPtr<T>& sp)
: _ptr(sp._ptr)
, _pCount(sp._pCount)
{
++(*_pCount);
}
SharedPtr<T>& operator=(const SharedPtr<T>& sp)
{
if (&sp != this)
{
if (--(*_pCount) == 0) // 减到0释放对象一次
{
delete _ptr;
delete _pCount;
}
_ptr = sp._ptr;
_pCount = sp._pCount;
++(*_pCount);
}
return *this;
}
~SharedPtr()
{
if (_ptr)
{
if (--(*_pCount) == 0)
{
delete _ptr;
delete _pCount;
}
}
}
T& operator*()
{
return *_ptr;
}
T* operator->()
{
return _ptr;
}
long GetCount()
{
return *(_pCount);
}
T* GetPtr()
{
return _ptr;
}
private:
T* _ptr;
long* _pCount;
};
void Test()
{
SharedPtr<int> sp1 = new int(1);
SharedPtr<int> sp2 = sp1;
SharedPtr<int> sp3 = new int(2);
sp3 = sp1;
}
int main()
{
Test();
return 0;
}
不到之处，还请评正。