C++RAII机制

什么是RAII?

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

为什么要使用RAII?

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

如何使用RAII?

当我们在一个函数内部使用局部变量,当退出了这个局部变量的作用域时,这个变量也就别销毁了;当这个变量是类对象时,这个时候,就会自动调用这个类的析构函数,而这一切都是自动发生的,不要程序员显示的去调用完成。这个也太好了,RAII就是这样去完成的。

由于系统的资源不具有自动释放的功能,而C++中的类具有自动调用析构函数的功能。如果把资源用类进行封装起来,对资源操作都封装在类的内部,在析构函数中进行释放资源。当定义的局部变量的生命结束时,它的析构函数就会自动的被调用,如此,就不用程序员显示的去调用释放资源的操作了。

使用RAII 机制的代码:

  1.  
    #include <iostream>
  2.  
    using namespace std;
  3.  
     
  4.  
    class ArrayOperation
  5.  
    {
  6.  
    public :
  7.  
    ArrayOperation()
  8.  
    {
  9.  
    m_Array = new int [10];
  10.  
    }
  11.  
     
  12.  
    void InitArray()
  13.  
    {
  14.  
    for (int i = 0; i < 10; ++i)
  15.  
    {
  16.  
    *(m_Array + i) = i;
  17.  
    }
  18.  
    }
  19.  
     
  20.  
    void ShowArray()
  21.  
    {
  22.  
    for (int i = 0; i <10; ++i)
  23.  
    {
  24.  
    cout<<m_Array[i]<<endl;
  25.  
    }
  26.  
    }
  27.  
     
  28.  
    ~ArrayOperation()
  29.  
    {
  30.  
    cout<< "~ArrayOperation is called" <<endl;
  31.  
    if (m_Array != NULL )
  32.  
    {
  33.  
    delete[] m_Array;
  34.  
    m_Array = NULL ;
  35.  
    }
  36.  
    }
  37.  
     
  38.  
    private :
  39.  
    int *m_Array;
  40.  
    };
  41.  
     
  42.  
    bool OperationA();
  43.  
    bool OperationB();
  44.  
     
  45.  
    int main()
  46.  
    {
  47.  
    ArrayOperation arrayOp;
  48.  
    arrayOp.InitArray();
  49.  
    arrayOp.ShowArray();
  50.  
    return 0;
  51.  
    }

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

  1.  
    template<class... _Mutexes>
  2.  
    class lock_guard
  3.  
    { // class with destructor that unlocks mutexes
  4.  
    public:
  5.  
    explicit lock_guard(_Mutexes&... _Mtxes)
  6.  
    : _MyMutexes(_Mtxes...)
  7.  
    { // construct and lock
  8.  
    _STD lock(_Mtxes...);
  9.  
    }
  10.  
     
  11.  
    lock_guard(_Mutexes&... _Mtxes, adopt_lock_t)
  12.  
    : _MyMutexes(_Mtxes...)
  13.  
    { // construct but don't lock
  14.  
    }
  15.  
     
  16.  
    ~lock_guard() _NOEXCEPT
  17.  
    { // unlock all
  18.  
    _For_each_tuple_element(
  19.  
    _MyMutexes,
  20.  
    [](auto& _Mutex) _NOEXCEPT { _Mutex.unlock(); });
  21.  
    }
  22.  
     
  23.  
    lock_guard(const lock_guard&) = delete;
  24.  
    lock_guard& operator=(const lock_guard&) = delete;
  25.  
    private:
  26.  
    tuple<_Mutexes&...> _MyMutexes;
  27.  
    };

在使用多线程时,经常会涉及到共享数据的问题,C++中通过实例化std::mutex创建互斥量,通过调用成员函数lock()进行上锁,unlock()进行解锁。不过这意味着必须记住在每个函数出口都要去调用unlock(),也包括异常的情况,这非常麻烦,而且不易管理。C++标准库为互斥量提供了一个RAII语法的模板类std::lock_guard,其会在构造函数的时候提供已锁的互斥量,并在析构的时候进行解锁,从而保证了一个已锁的互斥量总是会被正确的解锁。上面的代码正式<mutex>>头文件中的源码,其中还使用到很多C++11的特性,比如delete/noexcept等,有兴趣的同学可以查一下。

原文地址:https://www.cnblogs.com/buzhidao1/p/13410237.html