c++ - 如何处理必须以异常安全的方式获取多个资源的构造函数

Question

我有一个非平凡的类型，它拥有多个资源。如何以异常安全的方式构造它？

例如，这里有一个演示类 X包含 A 的数组:

#include "A.h"

class X
{
    unsigned size_ = 0;
    A* data_ = nullptr;

public:
    ~X()
    {
        for (auto p = data_; p < data_ + size_; ++p)
            p->~A();
        ::operator delete(data_);
    }

    X() = default;
    // ...
};

现在这个特定类的明显答案是使用std::vector<A> 。这是个好建议。但是X只是更复杂场景的替身，其中 X必须拥有多个资源，使用“使用 std::lib”的好建议并不方便。我选择用这个数据结构来交流这个问题仅仅是因为它很熟悉。

要一清二楚:如果你能设计你的X这样默认的 ~X()正确清理所有内容(“零规则”)，或者如果 ~X()只需要释放一个资源，那是最好的。然而，在现实生活中，~X()必须处理多种资源，而这个问题解决了这些情况。

所以这个类型已经有一个很好的析构函数和一个很好的默认构造函数。我的问题集中在一个重要的构造函数上，它需要两个 A 's，为它们分配空间，并构造它们:

X::X(const A& x, const A& y)
    : size_{2}
    , data_{static_cast<A*>(::operator new (size_*sizeof(A)))}
{
    ::new(data_) A{x};
    ::new(data_ + 1) A{y};
}

我有一个完全仪器化的测试类(class) A如果这个构造函数没有抛出异常，那么它工作得很好。以这个测试驱动为例:

int
main()
{
    A a1{1}, a2{2};
    try
    {
        std::cout << "Begin\n";
        X x{a1, a2};
        std::cout << "End\n";
    }
    catch (...)
    {
        std::cout << "Exceptional End\n";
    }
}

输出是:

A(int state): 1
A(int state): 2
Begin
A(A const& a): 1
A(A const& a): 2
End
~A(1)
~A(2)
~A(2)
~A(1)

我有 4 个构造函数和 4 个析构函数，每个析构函数都有一个匹配的构造函数。一切都很好。

但是，如果 A{2} 的复制构造函数抛出异常，我得到这个输出:

A(int state): 1
A(int state): 2
Begin
A(A const& a): 1
Exceptional End
~A(2)
~A(1)

现在我有 3 个构造，但只有 2 个破坏。 A源自 A(A const& a): 1已泄露!

解决这个问题的一种方法是在构造函数中加上 try/catch .然而，这种方法是不可扩展的。在每次分配资源后，我还需要另一个嵌套 try/catch测试下一个资源分配并取消分配已经分配的资源。捏住 Nose :

X(const A& x, const A& y)
    : size_{2}
    , data_{static_cast<A*>(::operator new (size_*sizeof(A)))}
{
    try
    {
        ::new(data_) A{x};
        try
        {
            ::new(data_ + 1) A{y};
        }
        catch (...)
        {
            data_->~A();
            throw;
        }
    }
    catch (...)
    {
        ::operator delete(data_);
        throw;
    }
}

这正确输出:

A(int state): 1
A(int state): 2
Begin
A(A const& a): 1
~A(1)
Exceptional End
~A(2)
~A(1)

但这是丑陋的!如果有 4 个资源怎么办？或者400？!如果资源的数量在编译时未知怎么办？!

有没有更好的方法？

Answer 1

Is there a better way?

是

C++11 提供了一个名为委托(delegate)构造函数的新特性，它非常优雅地处理了这种情况。但是有点微妙。

在构造函数中抛出异常的问题是要意识到你正在构造的对象的析构函数在构造函数完成之前不会运行。虽然子对象(基类和成员)的析构函数会在抛出异常时运行，但只要这些子对象完全构造完毕。

这里的关键是完全构造X 之前你开始添加资源，然后然后添加资源一个time，在添加每个资源时保持 X 处于有效状态。一旦 X 完全构建，~X() 将在您添加资源时清理所有困惑。在 C++11 之前，这可能看起来像:

X x;  // no resources
x.push_back(A(1));  // add a resource
x.push_back(A(2));  // add a resource
// ...

但在 C++11 中，您可以像这样编写多资源获取构造函数:

X(const A& x, const A& y)
    : X{}
{
    data_ = static_cast<A*>(::operator new (2*sizeof(A)));
    ::new(data_) A{x};
    ++size_;
    ::new(data_ + 1) A{y};
    ++size_;
}

这很像编写完全不了解异常安全的代码。不同的是这一行:

    : X{}

这表示:为我构造一个默认的 X。构造完成后，*this 就完全构造好了，如果后续操作抛出异常，~X() 就会运行。 这是革命性的!

请注意，在这种情况下，默认构造的 X 不会获取任何资源。事实上，它甚至是隐含的noexcept。所以那部分不会扔。并且它将 *this 设置为一个有效的 X，它包含一个大小为 0 的数组。~X() 知道如何处理该状态。

现在添加未初始化内存的资源。如果抛出，你仍然有一个默认构造的 X 和 ~X() 正确地处理它什么都不做。

现在添加第二个资源:x 的构造拷贝。如果抛出，~X() 仍将释放 data_ 缓冲区，但不会运行任何 ~A()。

如果第二个资源成功，通过增加 size_ 将 X 设置为有效状态，这是一个 noexcept 操作。如果在此之后抛出任何东西，~X() 将正确清理长度为 1 的缓冲区。

现在尝试第三个资源:y 的构造拷贝。如果该构造抛出，~X() 将正确清理长度为 1 的缓冲区。如果没有抛出，通知 *this 它现在拥有一个缓冲区长度 2。

使用这种技术不要求 X 是默认可构造的。例如，默认构造函数可以是私有(private)的。或者您可以使用其他一些将 X 置于无资源状态的私有(private)构造函数:

: X{moved_from_tag{}}

在 C++11 中，如果您的 X 可以具有无资源状态通常是一个好主意，因为这使您能够拥有一个捆绑的 noexcept 移动构造函数具有各种优点(并且是不同帖子的主题)。

C++11 委派构造函数是编写异常安全构造函数的一种非常好的(可扩展的)技术，只要您在开始时就可以构造一个无资源状态(例如 noexcept 默认构造函数)。

是的，在 C++98/03 中有一些方法可以做到这一点，但它们并不那么漂亮。您必须创建一个 X 的实现细节基类，其中包含 X 的销毁逻辑，但不包含构造逻辑。去过那里，做到了，我喜欢委托(delegate)构造函数。