1.什么是RAII技术
RAII（Resource Acquisition Is Initiialization）是一种利用对象生命周期来控制程序资源(如内存，文件句柄，网络连接，互斥量)的简单技术。
RAII的一般做法是这样的:在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。
借此，我们实际上把管理一份资源的责任托管给一个对象。这种做法有两大好处:
不需要显式地释放资源。当产生异常、回滚等现象时，RAII可以正确地释放掉资源。
采用这种方式，对象所需的资源在其生命期内始终保持有效。
2.
RAII的好处在于它提供了一种资源自动管理的方式，当产生异常、回滚等现象时，RAII可以正确地释放掉资源。
举个常见的例子：
void Func()
{
FILE *fp;
char* filename = "test.txt";
if((fp=fopen(filename,"r"))==NULL)
{
printf("not open");
exit(0);
}
... // 如果 在使用fp指针时产生异常 并退出
// 那么 fp文件就没有正常关闭
fclose(fp);
}
在资源的获取到释放之间，我们往往需要使用资源，但常常一些不可预计的异常是在使用过程中产生，就会使资源的释放环节没有得到执行。
此时，就可以让RAII惯用法大显身手了。
RAII的实现原理很简单，利用stack上的临时对象生命期是程序自动管理的这一特点，将我们的资源释放操作封装在一个临时对象中。
具体示例代码如下：
class Resource{};
class RAII{
public:
RAII(Resource* aResource):r_(aResource){} //获取资源
~RAII() {delete r_;} //释放资源
Resource* get() {return r_ ;} //访问资源
private:
Resource* r_;
};
比如文件操作的例子，我们的RAII临时对象类就可以写成：
class FileRAII{
public:
FileRAII(FILE* aFile):file_(aFile){}
~FileRAII() { fclose(file_); }//在析构函数中进行文件关闭
FILE* get() {return file_;}
private:
FILE* file_;
};
则上面这个打开文件的例子就可以用RAII改写为：
void Func()
{
FILE *fp;
char* filename = "test.txt";
if((fp=fopen(filename,"r"))==NULL)
{
printf("not open");
exit(0);
}
FileRAII fileRAII(fp);
... // 如果 在使用fp指针时产生异常 并退出
// 那么 fileRAII在栈展开过程中会被自动释放，析构函数也就会自动地将fp关闭
// 即使所有代码是都正确执行了，也无需手动释放fp，fileRAII它的生命期在此结束时，它的析构函数会自动执行！
}
这就是RAII的魅力，它免除了对需要谨慎使用资源时而产生的大量维护代码。在保证资源正确处理的情况下，还使得代码的可读性也提高了不少。
创建自己的RAII类
一般情况下，RAII临时对象不允许复制和赋值，当然更不允许在heap上创建，所以先写下一个RAII的base类，使子类私有继承Base类来禁用这些操作：
class Uncopyable{
protected: //允许derived对象构造和析构
Uncopyable(){}
~Uncopyable(){}
private:
Uncopyable(const Uncopyable&); //但阻止copying
Uncopyable& operator=(const Uncopyable&);
};
当我们要写自己的RAII类时就可以直接继承该类的实现：
template<class T>class RaiiResource:private Uncopyable
{
public:
explicit RaiiResource(T * aResource):pr(aResource){} //获取资源
~RaiiResource() {delete pr;} //释放资源
T* get() {return pr;} //访问资源
private:
T* pr;
};
将RaiiResource类做成模板类，这样就可以将class类型放入其中。另外， RaiiResource可以根据不同资源类型的释放形式来定义不同的析构函数。
由于不能使用该类的指针，所以使用虚函数是没有意义的。
注：自己写的RAII类并没有经过大量的实践，可能存在问题，请三思而慎用。这里只是记录下自己的实现想法。
3.实战应用
.1 scope lock (局部锁技术) （参见 ACE ACE_Gaurd 模板类的实现）
在很多时候，为了实现多线程之间的数据同步，我们会使用到 mutex,critical section,event,singal 等技术。但在使用过程中，由于各种原因，有时候，我们会遇到一个问题：
由于忘记释放（Unlock）锁，产生死锁现象。
采用RAII 就可以很好的解决这个问题,使用着不必担心释放锁的问题. 示例代码如下:
My_scope_lock 为实现 局部锁的模板类.
LockType 抽象代表具体的锁类 .如 基于 mutex 实现 mutex_lock 类.
template<class LockType>
class My_scope_lock
{
public:
My_scope_lock(LockType& _lock):m_lock(_lock)
{
m_lock.occupy();
}
~My_scope_lock()
{
m_lock.relase();
}
protected:
LockType m_lock;
};
开发中使用示例:
假设对Data 类中的数据操作需要 互斥控制.
class Data
{
public:
Data();
~Data();
bool getdata();
bool savedata();
bool update();
private:
mutex_lock m_mutex_lock;
};
在Update 方法中使用了局部锁 (scope_lock) .在Update 函数中我们声明了 My_Scope_Lock 局部变量.在My_Scope_Lock 的构造函数中我们
已经下达了对数据加以了保护的"命令". 大家都知道,当函数推出的时候,局部变量会自动被回收,也就是说 My_Scope_Lock 的析构函数会被自动的调用,
即自动释放锁.
这样永远都不会出现死锁现象.如果不使用局部锁技术,我们就要在函数的每一个出口处去释放锁,这样很容易出错,且代码不优雅不易维护.
bool class Data::Update()
{
My_scope_lock l_lock(m_mutex_lock);
if()
{
return false;
}
else
{
// execute
}
return true;
}
我们可以根据上面的这个例子类推出好多这样例子. 如,读写文件的时候,很容易忘记关闭文件,如果借用 RAII
技术,就可以规避这种错误.再如对数据库的访问,忘记断开数据库连接等等,都可以借助RAII 技术也解决.
.2 资源释放
资源释放方面，RAII有其特有的优势：如果使用scope(exit)的话，每个资源分配之后都需要用一个scope(exit)跟在后面保护起来；
而如果用RAII的话，一个资源申请就对应于一个RAII对象的构造，释放工作则被隐藏在对象的析构函数中，从而使代码主干保持了清爽。
尤其,当我们 使用 exception 异常处理机制时,RAII 会给我们带来很大的帮助.
3.请记住：
为防止资源泄露，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源。
两个常被使用的RAII class 分别是tr1::shared_ptr和auto_ptr。前面通常是较佳选择，因为其copy行为比较直观。若选择auto_ptr，复制动作会使它(被复制物)指向NULL.。
复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为(reference counting)。不过其他行为也都可能被实现。
APIs往往要求访问原始资源(raw resources),所以每一个RAII class应该提供一个"取得其所管理之资源"的办法。
对原始资源的访问可能经由显示转换或隐式转换。一般而言显示转换比较安全，但隐式转换对客户比较方便。
普通而常见的RAII class copying 行为是：抑制copying、施行引用计数法