使用局部对象管理资源的技术通常称为“资源获取就是初始化”。
这种通用技术依赖于构造函数和析构函数的性质以及它们与异常处理的交互作用
RAII要求,资源的有效期与持有资源的对象的生命期严格绑定,即由对象的构造函数完成资源的分配(获取),同时由析构函数完成资源的释放。在这种要求下,只要对象能正确地析构,就不会出现资源泄露问题。
在不失代码简洁性的同时,可以很好地保证代码的异常安全性。
//下面的C++实例说明了如何用RAII访问文件和互斥量:
#include
#include
#include
#include
#include
void write_to_file(const std::string & message)
{
// 创建关于文件的互斥锁
static std::mutex mutex;
// 在访问文件前进行加锁
std::lock_guard<std::mutex> lock(mutex);
// 尝试打开文件
std::ofstream file("example.txt");
if (!file.is_open())
throw std::runtime_error("unable to open file");
// 输出文件内容
file << message << std::endl;
// 当离开作用域时,文件句柄会被首先析构 (不管是否抛出了异常)
// 互斥锁也会被析构 (同样地,不管是否抛出了异常)
}
C++保证了所有栈对象在生命周期结束时会被销毁(即调用析构函数),所以该代码是异常安全的。无论在write_to_file函数正常返回时,还是在途中抛出异常时,都会引发write_to_file函数的堆栈回退,而此时会自动调用lock和file对象的析构函数。
当一个函数需要通过多个局部变量来管理资源时,RAII就显得非常好用。因为只有被构造成功(构造函数没有抛出异常)的对象才会在返回时调用析构函数,同时析构函数的调用顺序恰好是它们构造顺序的反序,这样既可以保证多个资源(对象)的正确释放,又能满足多个资源之间的依赖关系。
由于RAII可以极大地简化资源管理,并有效地保证程序的正确和代码的简洁,所以通常会强烈建议在C++中使用它。
我们可以将文件句柄FILE抽象为FileHandle类:
class FileHandle{
public:
FileHandle(const char* n,const char* a){ p = fopen(n,a)}
~FileHandle(){fclose(p);}
private:
//禁止拷贝操作
FileHandle(FileHandle const&);
FileHandle & operator = (const FileHandle &);
FILE *P;
};
FileHandle类的构造函数调用fopen()获取资源;FileHandle类的析构函数调用fclose()释放资源。请注意,考虑到FileHandle对象代表一种资源,它并不具有拷贝语义,因此我们将拷贝构造函数和赋值运算符声明为私有成员。如果利用FileHandle类的局部对象表示文件句柄资源,那么前面的UseFile函数便可简化为:
void UsrFile(const char* fn){
FileHandle file(fn,"r");
//此处使用文件句柄f
//超出此作用域,系统会自动调用file的析构函数,从而释放资源
}
例如,Widget类的构造函数要获取两个资源:文件myFile和互斥锁myLock。每个资源的获取都有可能失败并且抛出异常。
为了正常使用Widget对象,这里我们必须维护一个不变式(invariant):当调用构造函数时,要么两个资源全都获得,对象创建成功;要么两个资源都没得到,对象创建失败。获取了文件而没有得到互斥锁的情况永远不能出现,也就是说,不允许建立Widget对象的半成品。如果将RAII惯用法应用于成员对象,那么我们就可以实现这个不变式:
class Widget{
public:
Widget(const char* myFile,const char* myLock):file_(myFile),lock_(mylock){ }
//...
private:
FileHandle file_;
LockHandle lock_;
};
FileHandle和LockHandle类的对象作为Widget类的数据成员,分别表示需要获取的文件和互斥锁。资源的获取过程就是两个成员对象的初始化过程。在此系统会自动地为我们进行资源管理,程序员不必显式地添加任何异常处理代码。例如,当已经创建完file_,但尚未创建完lock_时,有一个异常被抛出,则系统会调用file_的析构函数,而不会调用lock_的析构函数。Bjarne所谓构造函数和析构函数“与异常处理的交互作用”,说的就是这种情形。
RAII在C++中的应用非常广泛,如C++标准库中的lock_guard便是用RAII方式来控制互斥量:
template <class Mutex> class lock_guard {
private:
Mutex& mutex_;
public:
lock_guard(Mutex& mutex) : mutex_(mutex) { mutex_.lock(); }
~lock_guard() { mutex_.unlock(); }
lock_guard(lock_guard const&) = delete;
lock_guard& operator=(lock_guard const&) = delete;
};
程序员可以非常方便地使用lock_guard,而不用担心异常安全问题
extern void unsafe_code(); // 可能抛出异常
using std::mutex;
using std::lock_guard;
mutex g_mutex;
void access_critical_section()
{
lock_guard<mutex> lock(g_mutex);
unsafe_code();
}