shared_ptr的使用心得

关键字: 资源获取即初始化 RAII 智能指针 boost shared_prt 资源泄露 内存泄露.

引言：

　　几乎所有复杂的程序可能都需要引用计数型智能指针。这种智能指针的最突出特点是当某个资源的引用次数为0时,证明该资源已经没有被使用，需要销毁。这时，智能指针会自动将它指向的资源销毁。
　　最典型的引用计数型智能指针的实现就是boost里的shared_ptr. 具体用法可以参考<<Beyond the C++ Standard Library: An Introduction to Boost>> shared_ptr一小节 或者参考网址：

http://hi.baidu.com/_%E2d_%B7%B3_%DE%B2%C2%D2/blog/item/7cc657339d5d23fc1a4cffa0.html

1.1
现在考虑如下一个资源从创建到销毁的过程:
{
int* pInt = new int(14);
...... // 此处有一系列代码
delete pInt;
}
　　如果程序在......这些代码的执行中跳出了异常。这样导致程序不会运行到delete pInt2这里，这时资源泄露了。

　　如何防止这种情况呢? 由此我们联想到类的构造和和类离开作用域时的自动析构.这就是资源获取即初始化技术。资源获取即初始化（RAII, Resource Acquisition Is Initialization）是指，当你

获得一个资源的时候，不管这个资源是对象、内存、文件句柄或者其它什么，你都要在一个对象的构造函数中获得它， 并且在该对象的析构函数中释放它。实现这种功能的类，我们就说它采用了"资源

获取即初始化（RAII）"的方式。这样的类常常被称为封装类。

下面为一个最简单的RAII:

class CMySingleLock
{
public:
CMySingleLock()
{
InitializeCriticalSection(&m_CritSec);
EnterCriticalSection(&m_CritSec);
}

~CMySingleLock (void)
{
LeaveCriticalSection(&m_CritSec);
DeleteCriticalSection(&m_CritSec);
}

private:
CRITICAL_SECTION m_CritSec;
};

这样就可以这样调用:

{

CMySingleLock mySingleLock;

....处理变量

} // 此处mySingleLock已经离开作用域,自动解锁

　　很多程序用到了该技术，如mutex, criticalSection. 这样，当你创建资源的时候就立即将它放入封装类对象构造函数（new出来的指针立即放入shared_ptr析造函数里), 当该对象离开作用域时，

对象析构函数会自动销毁资源（shared_ptr对象离开作用域时，会自动销毁指向的资源）.

1.2
　　shared_ptr是典型的资源获取即初始化技术。不过shared_ptr采用了更复杂一点RAII方式，因为它实现了引用计数。当创建资源的时候将它放入一个shared_ptr, shared_ptr内部记录对这种资源的引用次数为1次。当这个shared_ptr对象离开作用域时，引用次数减1，shared_ptr对象析构时，检查到引用次数为0了，就销毁资源:

{
boost::shared_ptr<int> pInt(new int(14));
assert(pInt.use_count() == 1); // new int(14)这个指针被引用1次
...... // 此处有一系列代码

} //pInt离开作用域, 所以new int(14)被引用次数为0. 指针被销毁。防止了

　　此处及以下assert代码都会判断成功。如果......跳出异常。那么pInt也离开了作用域，指针照常还是被销毁，所以智能指针可以有效防止资源泄露。

考虑更多次的引用情况：

{

boost::shared_ptr<int> pInt2;
assert(pInt2.use_count() == 0); // temp2还没有引用指针

{

boost::shared_ptr<int> pInt1(new int(14));
assert(pInt1.use_count() == 1); // new int(14)这个指针被引用1次

pInt2 = pInt1;
assert(pInt1.use_count() == 2); // new int(14)这个指针被引用2次
assert(pInt2.use_count() == 2);
} //pInt1离开作用域, 所以new int(14)被引用次数-1

assert(pInt2.use_count() == 1);
} // pInt2离开作用域，引用次数-1,现在new int(14)被引用0次，所以销毁它

不管资源曾经被多少次引用。当它被引用0次时就会销毁。

1.3

　　在shard_ptr使用中经常会发现，一个对象会有两次被析构的情况。其实这种是因为那个对象指针被两次当成shard_ptr构造函数里的参数。一定要避免这种现象。考虑如下代码：

{
int* pInt = new int(14);
boost::shared_ptr<int> temp1(pInt);
assert(temp1.use_count() == 1); // 用一个指针初始化temp1，temp1认为pInt只被它拥有。所以这个指针被引用1次

boost::shared_ptr<int> temp2(pInt); // 用一个指针初始化temp2，temp2认为pInt只被它拥有。所以这个指针被引用1次
assert(temp2.use_count() == 1);

} // temp1,temp2都离开作用域，它们都销毁pInt. pInt被销毁了两次！系统终于崩溃了 -_-

正确的做法是将原始指针赋给智能指针后,以后的操作都要针对智能指针了.

{
boost::shared_ptr<int> temp1(new int(14)); // 资源获取即初始化
assert(temp1.use_count() == 1);

boost::shared_ptr<int> temp2(temp1);
assert(temp2.use_count() == 2);

} // temp1,temp2都离开作用域，引用次数变为0,指针被销毁

1.4
如果资源的创建销毁不是以new，delete的方式创建销毁怎么办？shared_ptr也可以指定删除器：

// FileCloser.h　FileCloser删除器　　
class FileCloser
{
public:
void operator()(FILE *pf)
{
if (pf)
{
fclose(pf);
}
}
};

// 某实现文件
{
boost::shared_ptr<FILE> fp(fopen(pszConfigFile, "r"), FileCloser()); // 指定调用FileCloser函数对象销毁资源
}

1.5
　　shared_ptr已经被即将到来的标准库技术报告所采纳,将成为tr1中的一员。为了以后更好的移植现有代码到C++新标准中。可以使用一个namespace的一个小技巧，在头文件StdAfx.h中声明（参考

Effective C++ Item 54)：
namespace std

{

namespace tr1 = ::boost; // namespace std::tr1 is an alias

} // for namespace boost

这样就可以用如下方法写代码：

std::tr1::shared_ptr<int> pInt(new int(14));

1.6 完结

bla bla bla......