C++ 中的 RAII 和智能指针

Question

在 C++ 实践中，什么是RAII，什么是智能指针，它们是如何在程序中实现的以及将 RAII 与智能指针结合使用有什么好处？

Answer 1

RAII 的一个简单（可能被过度使用）的示例是 File 类。 如果没有 RAII，代码可能看起来像这样：

File file("/path/to/file");
// Do stuff with file
file.close();

换句话说，我们必须确保在完成文件后立即将其关闭。 这有两个缺点 - 首先，无论我们在哪里使用 File，我们都必须调用 File::close() - 如果我们忘记这样做，我们保存文件的时间就会比我们需要的时间长。 第二个问题是如果在我们关闭文件之前抛出异常怎么办？

Java 使用finally 子句解决第二个问题：

try {
    File file = new File("/path/to/file");
    // Do stuff with file
} finally {
    file.close();
}

或者从Java 7 开始，使用try-with-resource 语句：

try (File file = new File("/path/to/file")) {
   // Do stuff with file
}

C++ 使用RAII 解决这两个问题——即在File 的析构函数中关闭文件。 只要 File 对象在正确的时间被销毁（无论如何都应该如此），我们就可以关闭文件了。 所以，我们的代码现在看起来像这样：

File file("/path/to/file");
// Do stuff with file
// No need to close it - destructor will do that for us

这在 Java 中无法完成，因为无法保证对象何时被销毁，因此我们无法保证何时释放文件等资源。

关于智能指针——很多时候，我们只是在堆栈上创建对象。 例如（并从另一个答案中窃取一个示例）：

void foo() {
    std::string str;
    // Do cool things to or using str
}

这工作正常 - 但如果我们想返回 str 该怎么办？ 我们可以这样写：

std::string foo() {
    std::string str;
    // Do cool things to or using str
    return str;
}

那么，这有什么问题呢？ 嗯，返回类型是 std::string - 所以这意味着我们按值返回。 这意味着我们复制 str 并实际上返回副本。 这可能会很昂贵，而且我们可能希望避免复制它的成本。 因此，我们可能会想到通过引用或指针返回的想法。

std::string* foo() {
    std::string str;
    // Do cool things to or using str
    return &str;
}

不幸的是，这段代码不起作用。 我们返回一个指向 str 的指针 - 但 str 是在堆栈上创建的，因此一旦退出 foo()，我们就会被删除。 换句话说，当调用者获得指针时，它已经毫无用处了（而且可以说比无用更糟糕，因为使用它可能会导致各种奇怪的错误）

那么，解决方案是什么？ 我们可以使用 new 在堆上创建 str - 这样，当 foo() 完成时， str 不会被销毁。

std::string* foo() {
    std::string* str = new std::string();
    // Do cool things to or using str
    return str;
}

当然，这个解决方案也并不完美。 原因是我们创建了str，但我们从未删除它。 对于非常小的程序来说，这可能不是问题，但一般来说，我们希望确保将其删除。 我们可以说，调用者在使用完该对象后必须将其删除。 缺点是调用者必须管理内存，这增加了额外的复杂性，并且可能会出错，导致内存泄漏，即即使不再需要对象也不会删除该对象。

这就是智能指针的用武之地。以下示例使用shared_ptr - 我建议您查看不同类型的智能指针以了解您实际想要使用的内容。

shared_ptr<std::string> foo() {
    shared_ptr<std::string> str = new std::string();
    // Do cool things to or using str
    return str;
}

现在，shared_ptr 将计算对 str 的引用数量。 例如

shared_ptr<std::string> str = foo();
shared_ptr<std::string> str2 = str;

，现在有两个对同一字符串的引用。 一旦没有剩余的对 str 的引用，它将被删除。 因此，您不再需要担心自己删除它。

快速编辑：正如一些评论所指出的，这个例子并不完美，（至少！）有两个原因。 首先，由于字符串的实现，复制字符串往往很便宜。 其次，由于所谓的命名返回值优化，按值返回可能并不昂贵，因为编译器可以采取一些巧妙的措施来加快速度。

那么，让我们使用 File 类尝试一个不同的示例。

假设我们想使用一个文件作为日志。 这意味着我们想以仅追加模式打开文件：

File file("/path/to/file", File::append);
// The exact semantics of this aren't really important,
// just that we've got a file to be used as a log

现在，让我们将文件设置为其他几个对象的日志：

void setLog(const Foo & foo, const Bar & bar) {
    File file("/path/to/file", File::append);
    foo.setLogFile(file);
    bar.setLogFile(file);
}

不幸的是，这个示例结束得很糟糕 - 一旦此方法结束，文件将被关闭，这意味着 foo和 bar 现在有一个无效的日志文件。 我们可以在堆上构造文件，并将指向文件的指针传递给 foo 和 bar：

void setLog(const Foo & foo, const Bar & bar) {
    File* file = new File("/path/to/file", File::append);
    foo.setLogFile(file);
    bar.setLogFile(file);
}

但是谁负责删除文件呢？ 如果两者都没有删除文件，那么就会出现内存和资源泄漏。 我们不知道 foo 或 bar 是否会首先完成该文件，因此我们不能期望它们自己删除该文件。 例如，如果 foo 在 bar 完成之前删除了该文件，则 bar 现在有一个无效的指针。

因此，正如您可能已经猜到的，我们可以使用智能指针来帮助我们解决这个问题。

void setLog(const Foo & foo, const Bar & bar) {
    shared_ptr<File> file = new File("/path/to/file", File::append);
    foo.setLogFile(file);
    bar.setLogFile(file);
}

现在，没有人需要担心删除文件 - 一旦 foo 和 bar 都完成并且不再有任何对文件的引用（可能是由于 foo 和 bar 被破坏），文件将自动被删除。

Answer 2

RAII 对于一个简单但很棒的概念来说，这是一个奇怪的名字。 更好的名称是范围限制资源管理 (SBRM)。 这个想法是，您经常碰巧在块的开始处分配资源，并且需要在块的出口处释放它。 退出块可以通过正常的流控制、跳出它甚至通过异常来发生。 为了涵盖所有这些情况，代码变得更加复杂和冗余。

只是一个没有 SBRM 的例子：

void o_really() {
     resource * r = allocate_resource();
     try {
         // something, which could throw. ...
     } catch(...) {
         deallocate_resource(r);
         throw;
     }
     if(...) { return; } // oops, forgot to deallocate
     deallocate_resource(r);
}

正如你所看到的，我们有很多方法可以被攻击。 我们的想法是将资源管理封装到一个类中。 其对象的初始化获取资源（“资源获取即初始化”）。 当我们退出块（块作用域）时，资源再次被释放。

struct resource_holder {
    resource_holder() {
        r = allocate_resource();
    }
    ~resource_holder() {
        deallocate_resource(r);
    }
    resource * r;
};

void o_really() {
     resource_holder r;
     // something, which could throw. ...
     if(...) { return; }
}

如果您有自己的类，而这些类不仅仅用于分配/取消分配资源，那就太好了。 分配只是完成工作的一个额外问题。 但是，一旦您只想分配/取消分配资源，上述方法就变得不方便了。 您必须为您获取的每种资源编写一个包装类。 为了缓解这个问题，智能指针允许您自动执行该过程：

shared_ptr<Entry> create_entry(Parameters p) {
    shared_ptr<Entry> e(Entry::createEntry(p), &Entry::freeEntry);
    return e;
}

通常，智能指针是 new/delete 的薄包装器，当它们拥有的资源超出范围时，它们恰好会调用 delete 。 一些智能指针，例如shared_ptr，允许您告诉它们一个所谓的删除器，该删除器用于代替delete。 例如，只要您告诉shared_ptr正确的删除器，您就可以管理窗口句柄、正则表达式资源和其他任意内容。

有不同用途的不同智能指针：

unique_ptr

is a smart pointer which owns an object exclusively. It's not in boost, but it will likely appear in the next C++ Standard. It's non-copyable but supports transfer-of-ownership. Some example code (next C++):

代码：

unique_ptr<plot_src> p(new plot_src); // now, p owns
unique_ptr<plot_src> u(move(p)); // now, u owns, p owns nothing.
unique_ptr<plot_src> v(u); // error, trying to copy u

vector<unique_ptr<plot_src>> pv; 
pv.emplace_back(new plot_src); 
pv.emplace_back(new plot_src);

与auto_ptr不同，unique_ptr可以放入容器中，因为容器将能够保存不可复制（但可移动）的类型，例如流和unique_ptr。

scoped_ptr

is a boost smart pointer which is neither copyable nor movable. It's the perfect thing to be used when you want to make sure pointers are deleted when going out of scope.

代码：

void do_something() {
    scoped_ptr<pipe> sp(new pipe);
    // do something here...
} // when going out of scope, sp will delete the pointer automatically. 

shared_ptr

is for shared ownership. Therefor, it's both copyable and movable. Multiple smart pointer instances can own the same resource. As soon as the last smart pointer owning the resource goes out of scope, the resource will be freed. Some real world example of one of my projects:

代码：

shared_ptr<plot_src> p(new plot_src(&fx));
plot1->add(p)->setColor("#00FF00");
plot2->add(p)->setColor("#FF0000");
// if p now goes out of scope, the src won't be freed, as both plot1 and 
// plot2 both still have references. 

如您所见，绘图源（函数 fx）是共享的，但每个绘图源都有一个单独的条目，我们可以在其中设置颜色。 当代码需要引用智能指针拥有的资源但不需要拥有该资源时，可以使用weak_ptr 类。 您应该创建一个weak_ptr，而不是传递原始指针。 当它注意到您尝试通过weak_ptr访问路径访问资源时，即使没有shared_ptr再拥有该资源，它也会抛出异常。

Answer 3

前提和原因在概念上很简单。

RAII 是一种设计范例，可确保变量在其构造函数中处理所有需要的初始化，并在其析构函数中处理所有需要的清理。这将所有初始化和清理减少到一个步骤。

C++ 不需要 RAII，但越来越多的人认为使用 RAII 方法将生成更健壮的代码。

RAII 在 C++ 中有用的原因是，C++ 在本质上管理变量进入和离开作用域时的创建和销毁，无论是通过正常代码流还是通过异常触发的堆栈展开。 这是 C++ 中的免费赠品。

通过将所有初始化和清理与这些机制联系起来，您可以确保 C++ 也将为您处理这项工作。

在 C++ 中谈论 RAII 通常会引发对智能指针的讨论，因为指针是清理时特别脆弱。 当管理从 malloc 或 new 获取的堆分配内存时，程序员通常有责任在指针被销毁之前释放或删除该内存。 智能指针将使用 RAII 原理来确保在指针变量被销毁时，堆分配的对象也被销毁。

Answer 4

智能指针是 RAII 的变体。 RAII的意思是资源获取即初始化。 智能指针在使用前获取资源（内存），然后在析构函数中自动将其丢弃。 发生了两件事：

1. 我们总是在使用内存之前分配内存，即使我们不喜欢这样——很难用智能指针做其他的事情。 如果没有发生这种情况，您将尝试访问 NULL 内存，从而导致崩溃（非常痛苦）。
2. 即使出现错误，我们也会释放内存。 没有任何记忆被悬置。

例如，另一个例子是网络套接字 RAII。 在这种情况下：

1. 我们在使用网络套接字之前总是打开它，即使我们不喜欢 - 很难用 RAII 的其他方式来做到这一点。 如果您尝试在没有 RAII 的情况下执行此操作，您可能会打开空套接字，例如 MSN 连接。 那么像“今晚就做吧”之类的消息可能不会被转移，用户也不会被上床，而且你可能会面临被解雇的风险。
2. 即使出现错误，我们也会关闭网络套接字。 没有套接字挂起，因为这可能会阻止响应消息“肯定会在底部”返回发送者。

现在，正如您所看到的，RAII 在大多数情况下是一个非常有用的工具，因为它可以帮助人们上床。

智能指针的 C++ 源在网络上有数以百万计，包括我上面的回复。

Answer 5

Boost 有很多这样的内容，包括 Boost.Interprocess< 中的内容/a> 用于共享内存。 它极大地简化了内存管理，尤其是在令人头痛的情况下，例如当您有 5 个进程共享相同的数据结构时：当每个人都使用完一块内存时，您希望它自动被释放并释放。 不必坐在那里试图找出谁应该负责对一块内存调用delete，以免最终导致内存泄漏，或者指针被错误地释放两次并可能损坏整个堆。

Answer 6

void foo()
{
   std::string bar;
   //
   // more code here
   //
}

无论发生什么，一旦 foo() 函数的作用域被保留， bar 就会被正确删除。

在内部 std::string 实现通常使用引用计数指针。 因此，只有当字符串的副本之一发生更改时，才需要复制内部字符串。 因此，引用计数智能指针可以仅在必要时复制某些内容。

此外，内部引用计数使得当不再需要内部字符串的副本时可以正确删除内存。