理解术语和概念的含义 - RAII（资源获取即初始化）

Question

C++ 开发人员能否给我们详细描述一下 RAII 是什么、为什么它很重要以及它是否与其他语言有任何相关性？

我确实知道一点。 我相信它代表“资源获取就是初始化”。 然而，这个名字并不符合我（可能不正确）对 RAII 的理解：我的印象是 RAII 是一种初始化堆栈上对象的方法，这样，当这些变量超出范围时，析构函数将自动被调用导致资源被清理。

那么为什么不称为“使用堆栈触发清理”（UTSTTC：）？ 如何从那里到达“RAII”？

怎样才能在堆栈上创建一些东西来清理堆上的东西呢？ 另外，是否存在无法使用 RAII 的情况？ 您是否曾发现自己希望进行垃圾收集？ 至少有一个垃圾收集器可以用于某些对象，同时让其他对象得到管理？

谢谢。

Answer 1

那么为什么不称为“使用堆栈触发清理”（UTSTTC：）？

RAII 告诉您该怎么做：在构造函数中获取资源！ 我想补充一点：一种资源，一种构造函数。 UTSTTC 只是其中的一种应用，RAII 的用途远不止于此。

资源管理很糟糕。在这里，资源是指使用后需要清理的任何东西。 对许多平台上的项目的研究表明，大多数错误都与资源管理有关 - 在 Windows 上尤其糟糕（由于对象和分配器的类型很多）。

在 C++ 中，由于异常和（C++ 风格）模板的组合，资源管理特别复杂。 如需深入了解，请参阅 GOTW8）。

---

C++ 保证当且仅当构造函数成功时才会调用析构函数。 依靠这一点，RAII 可以解决许多普通程序员甚至可能没有意识到的棘手问题。 以下是“每当我返回时我的局部变量都会被销毁”之外的一些示例。

让我们从一个使用 RAII 的过于简单的 FileHandle 类开始：

class FileHandle
{
    FILE* file;

public:

    explicit FileHandle(const char* name)
    {
        file = fopen(name);
        if (!file)
        {
            throw "MAYDAY! MAYDAY";
        }
    }

    ~FileHandle()
    {
        // The only reason we are checking the file pointer for validity
        // is because it might have been moved (see below).
        // It is NOT needed to check against a failed constructor,
        // because the destructor is NEVER executed when the constructor fails!
        if (file)
        {
            fclose(file);
        }
    }

    // The following technicalities can be skipped on the first read.
    // They are not crucial to understanding the basic idea of RAII.
    // However, if you plan to implement your own RAII classes,
    // it is absolutely essential that you read on :)



    // It does not make sense to copy a file handle,
    // hence we disallow the otherwise implicitly generated copy operations.

    FileHandle(const FileHandle&) = delete;
    FileHandle& operator=(const FileHandle&) = delete;



    // The following operations enable transfer of ownership
    // and require compiler support for rvalue references, a C++0x feature.
    // Essentially, a resource is "moved" from one object to another.

    FileHandle(FileHandle&& that)
    {
        file = that.file;
        that.file = 0;
    }

    FileHandle& operator=(FileHandle&& that)
    {
        file = that.file;
        that.file = 0;
        return *this;
    }
}

如果构造失败（有例外），则不会调用任何其他成员函数（甚至析构函数）。

RAII 避免使用处于无效状态的对象。在我们使用对象之前，它就已经让我们的生活变得更加轻松。

现在，让我们看一下临时对象：

void CopyFileData(FileHandle source, FileHandle dest);

void Foo()
{
    CopyFileData(FileHandle("C:\\source"), FileHandle("C:\\dest"));
}

需要处理三种错误情况：无法打开文件、只能打开一个文件、两个文件都可以打开但复制文件失败。 在非 RAII 实现中，Foo 必须显式处理所有三种情况。

RAII 会释放已获取的资源，即使在一条语句中获取了多个资源。

现在，让我们聚合一些对象：

class Logger
{
    FileHandle original, duplex;   // this logger can write to two files at once!

public:

    Logger(const char* filename1, const char* filename2)
    : original(filename1), duplex(filename2)
    {
        if (!filewrite_duplex(original, duplex, "New Session"))
            throw "Ugh damn!";
    }
}

如果 original 的情况下，Logger 的构造函数将失败 的构造函数失败（因为 filename1 无法打开），duplex 的构造函数失败（因为 filename2 无法打开） )，或者写入 Logger 构造函数体内的文件失败。 在任何这些情况下，Logger 的析构函数都不会被调用 - 因此我们不能依赖 Logger 的析构函数来释放文件。 但如果original被构造，它的析构函数将在Logger构造函数的清理期间被调用。

RAII 简化了部分构建后的清理工作。

---

缺点：

缺点？ 所有问题都可以通过 RAII 和智能指针解决；-)

当您需要延迟获取、将聚合对象推送到堆上时，RAII 有时会很笨重。
想象一下 Logger 需要一个 SetTargetFile(const char* target)。 在这种情况下，仍然需要成为 Logger 成员的句柄需要驻留在堆上（例如，在智能指针中，以适当地触发句柄的销毁。）

我从来不希望确实是垃圾收集。 当我从事 C# 工作时，有时我会感到一阵幸福，因为我不需要关心，但更重要的是，我怀念所有可以通过确定性破坏创建的很酷的玩具。 （使用 IDisposable 并不能解决问题。）

我有一个特别复杂的结构，可能会从 GC 中受益，其中“简单”智能指针会导致多个类的循环引用。 我们通过仔细平衡强指针和弱指针蒙混过关，但任何时候我们想要改变什么，我们都必须研究一张大的关系图。 GC 可能会更好，但某些组件持有应尽快释放的资源。

---

关于 FileHandle 示例的注释：它并不是完整的，只是一个示例 - 但结果是不正确的。 感谢 Johannes Schaub 的指出和 FredOverflow 将其转变为正确的 C++0x 解决方案。 随着时间的推移，我已经习惯了此处记录的方法。

Answer 2

那里有很好的答案，所以我只是添加一些被遗忘的东西。

0. RAII 涉及范围

RAII 涉及两者：

1. 在构造函数中获取资源（无论什么资源），并在析构函数中取消获取它。
2. 在声明变量时执行构造函数，在变量超出作用域时自动执行析构函数。

其他人已经回答过了，我就不多说了。

1. 当使用 Java 或 C# 进行编码时，您已经使用了 RAII...

茹尔丹先生：什么！ 当我说：“妮可，把我的拖鞋拿给我，
给我睡前饮料，”那是散文？

哲学大师：是的，先生。

MONSIEUR JOURDAIN：四十多年来，我一直在谈论散文，但对此一无所知，我非常感谢您教会了我这一点。

— 莫里哀：中产阶级绅士，第二幕，第四场

正如 Jourdain 先生对散文所做的那样，C# 甚至 Java 人已经使用 RAII，但以隐藏的方式例如，下面的 Java 代码（即：在 C# 中以相同的方式编写，将 synchronized 替换为 lock)：

void foo()
{
   // etc.

   synchronized(someObject)
   {
      // if something throws here, the lock on someObject will
      // be unlocked
   }
 
   // etc.
}

... 已经使用 RAII：互斥锁获取是在关键字 (synchronized 或 lock），并且在退出作用域时取消获取。

它的表示法非常自然，即使对于从未听说过 RAII 的人也几乎不需要解释

C++ 的优点 。与 Java 和 C# 相比，任何事情都可以使用 RAII 来实现，例如，在 C++ 中没有直接内置的 synchronized 或 lock，但我们仍然可以。拥有他们。

在 C++ 中，可以这样写：

void foo()
{
   // etc.

   {
      Lock lock(someObject) ; // lock is an object of type Lock whose
                              // constructor acquires a mutex on
                              // someObject and whose destructor will
                              // un-acquire it 
   
      // if something throws here, the lock on someObject will
      // be unlocked
   }
 
   // etc.
}

可以像在 Java/C# 中一样轻松编写（使用 C++ 宏）：

#define LOCK(mm_mutex) \
if(Lock lock{mm_mutex}) {} \
else

void foo()
{
   // etc.

   LOCK(someObject)
   {
      // if something throws here, the lock on someObject will
      // be unlocked
   }
 
   // etc.
}

2. RAII 有其他用途

白兔：[唱歌]我迟到了/我迟到了/为了一个非常重要的约会。 / 没时间说“你好”。 / 再见。 / 我迟到了，我迟到了，我迟到了。

— 爱丽丝梦游仙境（迪士尼版，1951）

您知道何时调用构造函数（在对象声明处），并且您知道何时调用其相应的析构函数（在作用域的出口处） ，因此您只需一行即可编写几乎神奇的代码。 欢迎来到 C++ 仙境（至少从 C++ 开发人员的角度来看）。

例如，您可以编写一个计数器对象（我将其作为练习）并仅通过声明其变量来使用它，就像使用上面的锁对象一样：

void foo()
{
   double timeElapsed = 0 ;
   
   {
      Counter counter(timeElapsed) ;
      // do something lengthy
   }
   // now, the timeElapsed variable contain the time elapsed
   // from the Counter's declaration till the scope exit
}

当然，可以再次使用 Java/C# 方式编写一个宏：

void foo()
{
   double timeElapsed = 0 ;

   COUNTER(timeElapsed)
   {
      // do something lengthy
   }
   // now, the timeElapsed variable contain the time elapsed
   // from the Counter's declaration till the scope exit
}

3.为什么C++缺少finally？

[尖叫]这是最后倒计时！

— 欧洲：最后的倒计时（抱歉，我没有引号，这里...:-)

finally 子句在 C#/Java 中用于处理资源处置范围退出的情况（通过返回或抛出异常）。

精明的规范读者会注意到 C++ 没有finally 子句。 这不是一个错误，因为 C++ 不需要它，因为 RAII 已经处理了资源处置。 （相信我，编写 C++ 析构函数比编写正确的 Java finally 子句甚至 C# 的正确 Dispose 方法要容易得多）。

不过，有时，finally 子句还是很酷的。 我们可以用 C++ 来做吗？ 是的，我们可以！再次交替使用 RAII。

结论：RAII 不仅仅是 C++ 的哲学：它就是 C++

RAII？ 这是 C++！！！

——C++ 开发者的愤怒评论，被一位不起眼的斯巴达国王和他的 300 位朋友无耻地抄袭

当您在 C++ 方面达到一定程度的经验时，您开始考虑 RAII， 构造函数和析构函数自动执行的术语。

您开始考虑范围，并且{ 和} 字符成为代码中最重要的字符。

几乎所有内容都符合 RAII：异常安全、互斥体、数据库连接、数据库请求、服务器连接、时钟、操作系统句柄等，以及最后但并非最不重要的内存。

数据库部分是不可忽视的，因为，如果您愿意付出代价，您甚至可以以“事务性编程”风格进行编写，执行一行又一行的代码，直到最终决定是否您想要提交所有更改，或者，如果不可能，则恢复所有更改（只要每行至少满足强异常保证）。 （有关事务性编程，请参阅 Herb 的 Sutter 文章 的第二部分）。

就像拼图一样，一切都适合。

RAII 是 C++ 的重要组成部分，没有它，C++ 就不可能是 C++。

这解释了为什么经验丰富的 C++ 开发人员如此迷恋 RAII，以及为什么 RAII 是他们在尝试其他语言时首先搜索的内容。

它解释了为什么垃圾收集器虽然本身是一项伟大的技术，但从 C++ 开发人员的角度来看并不那么令人印象深刻：

• RAII 已经处理了 GC 处理的大部分情况，
• GC 比 RAII 处理纯托管循环引用的情况更好。对象（通过巧妙地使用弱指针来缓解）
• GC 仍然仅限于内存，而 RAII 可以处理任何类型的资源。
• 如上所述，RAII 可以做很多很多事情......

Answer 3

RAII 使用 C++ 析构函数语义来管理资源。 例如，考虑一个智能指针。 您有一个指针的参数化构造函数，它使用对象的地址初始化该指针。 您在堆栈上分配一个指针：

SmartPointer pointer( new ObjectClass() );

当智能指针超出范围时，指针类的析构函数将删除连接的对象。 指针是堆栈分配的，对象是堆分配的。

在某些情况下，RAII 没有帮助。 例如，如果您使用引用计数智能指针（如 boost::shared_ptr）并创建一个带有循环的类似图形的结构，您将面临内存泄漏的风险，因为循环中的对象将阻止彼此被释放。 垃圾收集将有助于解决这个问题。

Answer 4

我想比之前的回应更强烈一些。

RAII，资源获取即初始化意味着所有获取的资源都应该在对象初始化的上下文中获取。 这禁止“裸”资源获取。 基本原理是 C++ 中的清理工作基于对象，而不是基于函数调用。 因此，所有清理工作都应该由对象完成，而不是函数调用。 从这个意义上说，C++ 比 Java 等更面向对象。 Java 清理基于finally 子句中的函数调用。

Answer 5

我同意 cpitis 的观点。 但想补充一点，资源可以是任何东西，而不仅仅是内存。 资源可以是文件、临界区、线程或数据库连接。

之所以称为资源获取即初始化，是因为在构造控制资源的对象时获取资源，如果构造函数失败（即由于异常），则不会获取资源。 然后，一旦对象超出范围，资源就会被释放。 c++保证堆栈上所有已成功构造的对象都将被破坏（这包括基类和成员的构造函数，即使超类构造函数失败）。

RAII 背后的原理是使资源获取异常安全。 无论异常发生在哪里，所有获取的资源都会被正确释放。 然而，这确实依赖于获取资源的类的质量（这必须是异常安全的，但这很难）。

Answer 6

垃圾收集的问题在于您会失去对 RAII 至关重要的确定性破坏。 一旦变量超出范围，垃圾收集器就会决定何时回收该对象。 对象所持有的资源将继续保留，直到调用析构函数为止。

Answer 7

RAII 来自资源分配即初始化。 基本上，这意味着当构造函数完成执行时，构造的对象已完全初始化并可供使用。 它还意味着析构函数将释放该对象拥有的任何资源（例如内存、操作系统资源）。

与垃圾收集语言/技术（例如Java、.NET）相比，C++ 允许完全控制对象的生命周期。 对于堆栈分配的对象，您将知道何时调用该对象的析构函数（当执行超出范围时），这在垃圾收集的情况下不受真正控制。 即使在 C++ 中使用智能指针（例如 boost::shared_ptr），您也会知道，当没有对所指向对象的引用时，将调用该对象的析构函数。

Answer 8

如何在堆栈上创建一些东西来清理堆上的东西？

class int_buffer
{
   size_t m_size;
   int *  m_buf;

   public:
   int_buffer( size_t size )
     : m_size( size ), m_buf( 0 )
   {
       if( m_size > 0 )
           m_buf = new int[m_size]; // will throw on failure by default
   }
   ~int_buffer()
   {
       delete[] m_buf;
   }
   /* ...rest of class implementation...*/

};


void foo() 
{
    int_buffer ib(20); // creates a buffer of 20 bytes
    std::cout << ib.size() << std::endl;
} // here the destructor is called automatically even if an exception is thrown and the memory ib held is freed.

当 int_buffer 实例存在时，它必须有一个大小，并且它将分配必要的内存。 当它超出范围时，它的析构函数被调用。 这对于同步对象之类的事情非常有用。 考虑

class mutex
{
   // ...
   take();
   release();

   class mutex::sentry
   {
      mutex & mm;
      public:
      sentry( mutex & m ) : mm(m) 
      {
          mm.take();
      }
      ~sentry()
      {
          mm.release();
      }
   }; // mutex::sentry;
};
mutex m;

int getSomeValue()
{
    mutex::sentry ms( m ); // blocks here until the mutex is taken
    return 0;  
} // the mutex is released in the destructor call here.

此外，是否存在无法使用 RAII 的情况？

不，不是真的。

您是否曾发现自己希望进行垃圾收集？ 至少有一个垃圾收集器可以用于某些对象，同时让其他对象受到管理？

绝不。 垃圾收集仅解决动态资源管理的一小部分。

Answer 9

这里已经有很多很好的答案，但我想补充一点：
RAII 的一个简单解释是，在 C++ 中，只要超出范围，在堆栈上分配的对象就会被销毁。 这意味着，将调用对象析构函数并可以执行所有必要的清理。
这意味着，如果创建一个对象时没有“new”，则不需要“delete”。 这也是“智能指针”背后的想法 - 它们驻留在堆栈上，并且本质上包装了基于堆的对象。

Answer 10

RAII 是资源获取即初始化的缩写。

这种技术对于 C++ 来说非常独特，因为它们支持构造函数和构造函数。 析构函数和 几乎自动匹配传入参数的构造函数，或者最坏的情况是默认构造函数被称为 & 如果显式提供，则调用析构函数；否则，如果您没有为 C++ 类显式编写析构函数，则调用 C++ 编译器添加的默认析构函数。 这种情况仅发生在自动管理的 C++ 对象上 - 这意味着不使用自由存储（使用 new、new[]/delete、delete[] C++ 运算符分配/释放内存）。

RAII 技术利用这种自动管理对象功能来处理在堆/自由存储上创建的对象，方法是使用 new/new[] 显式请求更多内存，这些对象应通过调用 delete/delete[] 显式销毁。 自动管理对象的类将包装在堆/自由存储内存上创建的另一个对象。 因此，当运行自动管理对象的构造函数时，将在堆/自由存储内存和包装上创建包装对象。 当自动管理对象的句柄超出范围时，会自动调用该自动管理对象的析构函数，其中使用删除来销毁包装的对象。 使用 OOP 概念，如果您将此类对象包装在私有范围内的另一个类中，您将无法访问包装的类成员和对象。 方法与方法 这就是设计智能指针（又名句柄类）的原因。 这些智能指针将包装的对象作为类型化对象公开给外部世界和外部世界。 允许调用公开的内存对象组成的任何成员/方法。 请注意，智能指针根据不同的需求有不同的风格。 您应该参考 Andrei Alexandrescu 的 Modern C++ 编程或 boost 库 (www.boostorg) 的shared_ptr.hpp 实现/文档来了解更多信息。 希望这可以帮助您了解 RAII。