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

问：

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

例如，下面是一个演示类，其中包含一个数组：XA

#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>。这是一个很好的建议。但这只是必须拥有多个资源的更复杂场景的替代品，并且使用“使用 std：：lib”的好建议并不方便。我选择用这种数据结构来传达这个问题，仅仅是因为它很熟悉。XX

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

所以这个类型已经有一个很好的析构函数，以及一个好的默认构造函数。我的问题集中在一个不平凡的构造函数上，它接受两个 '，为它们分配空间，然后构造它们：A

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};
}

我有一个完全插桩的测试类，如果这个构造函数没有抛出异常，它运行良好。例如，使用此测试驱动程序：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 个破坏。结果已经泄露了！AA(A const& a): 1

解决此问题的一种方法是将构造函数与 .但是，此方法不可扩展。在每次资源分配之后，我都需要另一个嵌套来测试下一个资源分配并取消分配已分配的内容。握住鼻子：try/catchtry/catch

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？！如果在编译时不知道资源数量怎么办？！

有没有更好的方法？