有人可以准确解释如果在堆上分配对象数组的过程中抛出异常会发生什么吗？

Question

我定义了一个类 foo 如下：

class foo {
private:
   static int objcnt;
public:
   foo() {
       if(objcnt==8)
           throw outOfMemory("No more space!");
       else
          objcnt++;
   }

   class outOfMemory {
   public:
       outOfMemory(char* msg) { cout << msg << endl;}
   };

   ~foo() { cout << "Deleting foo." << endl; objcnt--;}
};
int foo::objcnt = 0;

这是主要函数：

int main() {
    try {
            foo* p = new foo[3];
            cout << "p in try " << p << endl;
            foo* q = new foo[7];
        }catch(foo::outOfMemory& o) {
           cout << "Out-of-memory Exception Caught." << endl;
        }
}

很明显，“foo* q = new foo[7];”这一行只成功创建了5个对象，第6个对象抛出Out-of-memory异常。但事实证明，只有 5 个析构函数调用，并且 p 指向的位置存储的 3 个对象的数组没有调用析构函数。所以我想知道为什么？为什么程序只调用这 5 个对象的析构函数？

Answer 1

“原子”C++ 分配和构造函数是正确的并且是异常安全的： If new T;抛出，没有任何泄漏，并且如果 new T[N] 在此过程中的任何地方抛出，则已经构造的所有内容都会被销毁。所以没什么好担心的。

现在题外话：

您始终必须担心的是在任何单一责任单元中使用多个new表达式。基本上，您必须将任何 new 表达式视为烫手山芋，需要由完整构造的、负责任的监护对象吸收。

将 new 和 new[] 严格视为库构建块：您永远不会在高级用户代码中使用它们（也许除了单个 new< /code> 在构造函数中），并且仅在库类中。

也就是说：

// BAD:
A * p = new A;
B * q = new B;  // Ouch -- *p may leak if this throws!

// Good:
std::unique_ptr<A> p(new A);
std::unique_ptr<B> q(new B); // who cares if this throws
std::unique_ptr<C[3]> r(new C[3]); // ditto

另一方面：标准库容器实现了类似的行为：如果您说resize(N)（增长），并且在任何构造期间发生异常，那么所有已构造的元素都会被销毁。也就是说，resize(N) 要么将容器增大到指定的大小，要么根本不增大。 _{（例如，在 GCC 4.6 中，请参阅 bits/vector.tcc 中 _M_fill_insert() 的实现，了解异常检查范围构造的库版本。）}

Answer 2

仅针对完全构造的对象调用析构函数 - 这些对象的构造函数正常完成。仅当 new[] 正在进行时引发异常时，才会自动发生这种情况。因此，在您的示例中，析构函数将为在 q = new foo[7] 运行期间完全构造的五个对象运行。

由于 p 指向的数组的 new[] 已成功完成，因此该数组现在已由您的代码处理，并且 C++ 运行时不再关心它 - 没有析构函数除非您执行delete[] p，否则将运行。

Answer 3

当您在堆上声明数组时，您会得到预期的行为：

int main()
{
    try
    {
        foo   p[3];
        cout << "p in try " << p << endl;
        foo   q[7];
    }
    catch(foo::outOfMemory& o)
    {
       cout << "Out-of-memory Exception Caught." << endl;
    }
}

在您的代码中，只有指针是本地自动变量。当堆栈展开时，指针没有任何关联的清理。正如其他人指出的那样，这就是为什么 C++ 代码中通常没有 RAW 指针，它们通常包装在使用构造函数/析构函数来控制其生命周期的类对象中（智能指针/容器）。

作为旁注。使用 std::vector 通常比使用原始数组更好（在 C++11 中，如果您有固定大小的数组，则 std::array 也很有用）。这是因为堆栈的大小有限，而这些对象将大量数据放入堆中。这些类对象提供的额外方法使它们在代码的其余部分中更容易处理，并且如果您绝对必须有一个旧式数组指针来传递给 C 函数，那么它们很容易获得。

int main()
{
    try
    {
        std::vector<foo>     p(3);
        cout << "p in try " << p << endl;
        std::vector<foo>     q(7);

        // Now you can pass p/q to function much easier.

    }
    catch(foo::outOfMemory& o)
    {
       cout << "Out-of-memory Exception Caught." << endl;
    }
}