转载:http://www.jellythink.com/archives/101

什么是RAII?

RAII是Resource Acquisition Is Initialization的简称,是C++语言的一种管理资源、避免泄漏的惯用法。利用的就是C++构造的对象最终会被销毁的原则。RAII的做法是使用一个对象,在其构造时获取对应的资源,在对象生命期内控制对资源的访问,使之始终保持有效,最后在对象析构的时候,释放构造时获取的资源。

RAII的本质内容是用对象代表资源,把管理资源的任务转化为管理对象的任务,将资源的获取和释放与对象的构造和析构对应起来,从而确保在对象的生存期内资源始终有效,对象销毁时资源一定会被释放。说白了,就是拥有了对象,就拥有了资源,对象在,资源则在。所以,RAII机制是进行资源管理的有力武器,

使用方法,把资源放到类中或者作为全局变量,在类的构造函数中分配,析构函数中释放,使用资源时只要使用该类的对象作为局部变量就可以做到自动分配销毁资源了

为什么要使用RAII?

上面说到RAII是用来管理资源、避免资源泄漏的方法。那么,用了这么久了,也写了这么多程序了,口头上经常会说资源,那么资源是如何定义的?在计算机系统中,资源是数量有限且对系统正常运行具有一定作用的元素。比如:网络套接字、互斥锁、文件句柄和内存等等,它们属于系统资源。由于系统的资源是有限的,就好比自然界的石油,铁矿一样,不是取之不尽,用之不竭的,所以,我们在编程使用系统资源时,都必须遵循一个步骤:

  1. 申请资源;
  2. 使用资源;
  3. 释放资源。

第一步和第二步缺一不可,因为资源必须要申请才能使用的,使用完成以后,必须要释放,如果不释放的话,就会造成资源泄漏。

一个最简单的例子:

#include <iostream> 

using namespace std; 

int main() 

{
int *testArray = new int [];
// Here, you can use the array
delete [] testArray;
testArray = NULL ;
return ;
}

我们使用new开辟的内存资源,如果我们不进行释放的话,就会造成内存泄漏。所以,在编程的时候,new和delete操作总是匹配操作的。如果总是申请资源而不释放资源,最终会导致资源全部被占用而没有资源可用的场景。但是,在实际的编程中,我们总是会各种不小心的就把释放操作忘了,就是编程的老手,在几千行代码,几万行中代码中,也会犯这种低级的错误。

再来一个例子:

 #include <iostream>
using namespace std; bool OperationA();
bool OperationB(); int main()
{
int *testArray = new int []; // Here, you can use the array
if (!OperationA())
{
// If the operation A failed, we should delete the memory
delete [] testArray;
testArray = NULL ;
return ;
} if (!OperationB())
{
// If the operation A failed, we should delete the memory
delete [] testArray;
testArray = NULL ;
return ;
} // All the operation succeed, delete the memory
delete [] testArray;
testArray = NULL ;
return ;
} bool OperationA() {
// Do some operation, if the operate succeed, then return true, else return false
return false ;
} bool OperationB() {
// Do some operation, if the operate succeed, then return true, else return false
return true ;
}

上述这个例子的模型,在实际中是经常使用的,我们不能期待每个操作都是成功返回的,所以,每一个操作,我们需要做出判断,上述例子中,当操作失败时,然后,释放内存,返回程序。上述的代码,极度臃肿,效率下降,更可怕的是,程序的可理解性和可维护性明显降低了,当操作增多时,处理资源释放的代码就会越来越多,越来越乱。如果某一个操作发生了异常而导致释放资源的语句没有被调用,怎么办?这个时候,RAII机制就可以派上用场了。

如何使用RAII?

当我们在一个函数内部使用局部变量,当退出了这个局部变量的作用域时,这个变量也就别销毁了;当这个变量是类对象时,这个时候,就会自动调用这个类的析构函数,而这一切都是自动发生的,不要程序员显示的去调用完成。这个也太好了,RAII就是这样去完成的。由于系统的资源不具有自动释放的功能,而C++中的类具有自动调用析构函数的功能。如果把资源用类进行封装起来,对资源操作都封装在类的内部,在析构函数中进行释放资源。当定义的局部变量的生命结束时,它的析构函数就会自动的被调用,如此,就不用程序员显示的去调用释放资源的操作了。现在,我们就用RAII机制来完成上面的例子。代码如下:

 #include <iostream>
using namespace std; class ArrayOperation
{
public :
ArrayOperation()
{
m_Array = new int [];
} void InitArray()
{
for (int i = ; i < ; ++i)
{
*(m_Array + i) = i;
}
} void ShowArray()
{
for (int i = ; i <; ++i)
{
cout<<m_Array[i]<<endl;
}
} ~ArrayOperation()
{
cout<< "~ArrayOperation is called" <<endl;
if (m_Array != NULL )
{
delete[] m_Array;
m_Array = NULL ;
}
} private :
int *m_Array;
}; bool OperationA();
bool OperationB(); int main()
{
ArrayOperation arrayOp;
arrayOp.InitArray();
arrayOp.ShowArray();
return ;
}

上面这个例子没有多大的实际意义,只是为了说明RAII的机制问题。下面说一个具有实际意义的例子:

 /*
** FileName : RAII
** Author : Jelly Young
** Date : 2013/11/24
** Description : More information, please go to http://www.jellythink.com
*/ #include <iostream>
#include <windows.h>
#include <process.h> using namespace std; CRITICAL_SECTION cs;
int gGlobal = ; class MyLock
{
public:
MyLock()
{
EnterCriticalSection(&cs);
} ~MyLock()
{
LeaveCriticalSection(&cs);
} private:
MyLock( const MyLock &);
MyLock operator =(const MyLock &);
}; void DoComplex(MyLock &lock ) 2014.04.
{
} unsigned int __stdcall ThreadFun(PVOID pv)
{
MyLock lock;
int *para = (int *) pv; // I need the lock to do some complex thing
DoComplex(lock); for (int i = ; i < ; ++i)
{
++gGlobal;
cout<< "Thread " <<*para<<endl;
cout<<gGlobal<<endl;
}
return ;
} int main()
{
InitializeCriticalSection(&cs); int thread1, thread2;
thread1 = ;
thread2 = ; HANDLE handle[];
handle[] = ( HANDLE )_beginthreadex(NULL , , ThreadFun, ( void *)&thread1, , NULL );
handle[] = ( HANDLE )_beginthreadex(NULL , , ThreadFun, ( void *)&thread2, , NULL );
WaitForMultipleObjects(, handle, TRUE , INFINITE );
return ;
}

这个例子可以说是实际项目的一个模型,当多个进程访问临界变量时,为了不出现错误的情况,需要对临界变量进行加锁;上面的例子就是使用的Windows的临界区域实现的加锁。但是,在使用CRITICAL_SECTION时,EnterCriticalSection和LeaveCriticalSection必须成对使用,很多时候,经常会忘了调用LeaveCriticalSection,此时就会发生死锁的现象。当我将对CRITICAL_SECTION的访问封装到MyLock类中时,之后,我只需要定义一个MyLock变量,而不必手动的去显示调用LeaveCriticalSection函数。

上述的两个例子都是RAII机制的应用,理解了上面的例子,就应该能理解了RAII机制的使用了。

使用RAII的陷阱

在使用RAII时,有些问题是需要特别注意的。容我慢慢道来。

先举个例子:

 #include <iostream>
#include <windows.h>
#include <process.h> using namespace std; CRITICAL_SECTION cs;
int gGlobal = ; class MyLock
{
public:
MyLock()
{
EnterCriticalSection(&cs);
} ~MyLock()
{
LeaveCriticalSection(&cs);
} private:
//MyLock(const MyLock &);
MyLock operator =(const MyLock &);
}; void DoComplex(MyLock lock)
{
} unsigned int __stdcall ThreadFun(PVOID pv)
{
MyLock lock;
int *para = (int *) pv; // I need the lock to do some complex thing
DoComplex(lock); for (int i = ; i < ; ++i)
{
++gGlobal;
cout<< "Thread " <<*para<<endl;
cout<<gGlobal<<endl;
}
return ;
} int main()
{
InitializeCriticalSection(&cs); int thread1, thread2;
thread1 = ;
thread2 = ; HANDLE handle[];
handle[] = ( HANDLE )_beginthreadex(NULL , , ThreadFun, ( void*)&thread1, , NULL );
handle[] = ( HANDLE )_beginthreadex(NULL , , ThreadFun, ( void*)&thread2, , NULL );
WaitForMultipleObjects(, handle, TRUE , INFINITE );
return ;
}

这个例子是在上个例子上的基础上进行修改的。添加了一个DoComplex函数,在线程中调用该函数,该函数很普通,但是,该函数的参数就是我们封装的类。你运行该代码,就会发现,加入了该函数,对gGlobal全局变量的访问整个就乱了。你有么有想过,这是为什么呢?网上很多讲RAII的文章,都只是说了这个问题,但是没有说为什么,在这里,我好好的分析一下这里。

由于DoComplex函数的参数使用的传值,此时就会发生值的复制,会调用类的复制构造函数,生成一个临时的对象,由于MyLock没有实现复制构造函数,所以就是使用的默认复制构造函数,然后在DoComplex中使用这个临时变量。当调用完成以后,这个临时变量的析构函数就会被调用,由于在析构函数中调用了LeaveCriticalSection,导致了提前离开了CRITICAL_SECTION,从而造成对gGlobal变量访问冲突问题,如果在MyLock类中添加以下代码,程序就又能正确运行:

MyLock( const MyLock & temp )
{
EnterCriticalSection(&cs);
}

这是因为CRITICAL_SECTION 允许多次EnterCriticalSection,但是,LeaveCriticalSection必须和EnterCriticalSection匹配才能不出现死锁的现象。

为了避免掉进了这个陷阱,同时考虑到封装的是资源,由于资源很多时候是不具备拷贝语义的,所以,在实际实现过程中,MyLock类应该如下:

class MyLock
{
public:
MyLock()
{
EnterCriticalSection(&cs);
} ~MyLock()
{
LeaveCriticalSection(&cs);
} private:
MyLock(const MyLock &);
MyLock operator =(const MyLock &);
};

这样就防止了背后的资源复制过程,让资源的一切操作都在自己的控制当中。如果要知道复制构造函数和赋值操作符的调用,可以好好的阅读一下《深度探索C++对象模型这本书》。

总结

说了这么多了,RAII的本质内容是用对象代表资源,把管理资源的任务转化为管理对象的任务,将资源的获取和释放与对象的构造和析构对应起来,从而确保在对象的生存期内资源始终有效,对象销毁时资源一定会被释放。说白了,就是拥有了对象,就拥有了资源,对象在,资源则在。所以,RAII机制是进行资源管理的有力武器,C++程序员依靠RAII写出的代码不仅简洁优雅,而且做到了异常安全。在以后的编程实际中,可以使用RAII机制,让自己的代码更漂亮。

RAII的更多相关文章

  1. The RAII Programming Idiom

    https://www.hackcraft.net/raii/ https://en.wikipedia.org/wiki/Resource_Acquisition_Is_Initialization

  2. Resource Acquisition Is Initialization(RAII Idiom)

    原文链接:http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Resource_Acquisition_Is_Initialization Intent ...

  3. 使用智能指针来管理对象 (基于RAII)

    ////一个简单的防止内存泄露的例子//void test() { //使用RAII的特性管理资源 //当智能指针unique_ptr被销毁时,它指向的对象也将被销毁 //这里test函数返回后 p将 ...

  4. RAII惯用法详解

    [1]什么是RAII惯用法? RAII是Resource Acquisition Is Initialization的缩写,意为“资源获取即初始化”. 它是C++之父Bjarne Stroustrup ...

  5. C++中的RAII机制

    http://www.jellythink.com/archives/101 前言 在写C++设计模式——单例模式的时候,在写到实例销毁时,设计的GC类是很巧妙的,而这一巧妙的设计就是根据当对象的生命 ...

  6. 【原创】利用C++ RAII技术自动回收堆内存

    [说明]这篇文章本来发布在我个人网站的博客上,但由于:1,打算以cnblogs为家了:2. 关于智能指针部分需要修订,所有将修订版发在这里,作为第一篇文章. 常遇到的动态内存回收问题 在C++的编程过 ...

  7. C++11的资源管理:泛化的RAII

    RAII被认为是c++资源管理的最佳范式,但是c++98中用RAII必须为要管理的资源写一个类,这样一来RAII的使用就有些繁琐了.C++11有了lambda和function后,我们就可以编写泛化的 ...

  8. C++11的新特性lambda的小试牛刀RAII

    C/C++的资源是手动管理的 这导致程序员在申请资源时,最后用完了偶尔会忘记回收 C++语言的发明者倡导RAII,资源获取即初始化 使用对象来管理资源的生命周期,在超出作用域时,析构函数自动释放资源 ...

  9. c++ RAII 资源管理就是初始化

    RAII:(Resource Acquisition Is Initialization),也就是“资源获取就是初始化”,是C++语言的一种管理资源.避免泄漏的惯用法.C++标准保证任何情况下,已构造 ...

  10. RAII(Resource Acquisition Is Initialization)资源获得式初始化

    当在编写代码中用到异常,非常重要的一点是:“如果异常发生,程序占用的资源都被正确地清理了吗?” 大多数情况下不用担心,但是在构造函数里有一个特殊的问题:如果一个对象的构造函数在执行过程中抛出异常,那么 ...

随机推荐

  1. solr基础使用概述

    概述:solr 作为搜索引擎系统,它应该包含两部分内容,分别是:索引系统 和 搜索系统. 索引系统 它主要负责将外部不同数据源的数据转换为 solr 格式规范的数据格式(我们称之为:SolrInput ...

  2. ZeroMQ API(五) 传输模式

    1.使用TCP的单播传输:zmq_tcp(7) 1.1 名称 zmq_tcp - 使用TCP的ZMQ单播传输 1.2 概要 TCP是一种无处不在,可靠的单播传输.当通过具有ZMQ的网络连接分布式应用程 ...

  3. List(JDK1.7)(3)

    Vector 实现了一个存储对象的增长数组.如同一个数组,它可以使用一个整型下标来访问元素.但是,vector的大小是可以根据需要增长或收缩的. 每个vector通过维护capacity和capaci ...

  4. 你都掌握了吗?jQuery 选择器大全

    在 Dom 编程中我们只能使用有限的函数根据 id 或者 TagName 获取 Dom 对象. 然而在 jQuery 中则完全不同,jQuery 提供了异常强大的选择器用来帮助我们获取页面上的对象, ...

  5. soj1011. Lenny's Lucky Lotto

    1011. Lenny's Lucky Lotto Constraints Time Limit: 1 secs, Memory Limit: 32 MB Description Lenny like ...

  6. Javascript实现返回上一页面并刷新

    今天写了一个小小的提示成功的页面,同时要求返回上一页面,并实现对上一页面的操作进行刷新(例如删除的,添加的),在网上搜寻了一遍,基本上90%的都是说的是用window.history.go(-1), ...

  7. fvwm:还是觉得你最好

    2008-07-12的老日志 用了gnome和xfce,还是有些厌了,摆弄了两天fvwm,发现虽然配置起来有点麻烦,但用起来还是它最贴心,而且占资源极少,系统使用过程中内存一直只用了五六十兆.我的鼠标 ...

  8. 【leetcode 简单】 第七十九题 区域和检索 - 数组不可变

    给定一个整数数组  nums,求出数组从索引 i 到 j  (i ≤ j) 范围内元素的总和,包含 i,  j 两点. 示例: 给定 nums = [-2, 0, 3, -5, 2, -1],求和函数 ...

  9. 天梯赛 L2-023. (模拟) 图着色问题

    题目链接 题目描述 图着色问题是一个著名的NP完全问题.给定无向图 G = (V, E),问可否用K种颜色为V中的每一个顶点分配一种颜色,使得不会有两个相邻顶点具有同一种颜色? 但本题并不是要你解决这 ...

  10. POJ 3468 A Simple Problem with Integers (区间更新+区间查询)

    题目链接 Description You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operation ...