c++ - 如果分配该数组引发异常，您是否应该释放该数组？

Question

我有一个其他人编写的可能不稳定的类，我必须创建该类的对象数组。我提到这个类是不稳定的，所以它可能偶尔会在默认构造函数中抛出异常。我无法访问源代码，只能访问已编译的二进制文件。

当我使用 new 分配这些类型的对象的动态数组时，这些坏对象之一可能会引发异常。它抛出一个自定义异常，而不是 std::bad_alloc。无论如何，我需要让程序从异常中恢复并继续运行，尽管设置了一些错误标志等等。我认为我应该删除与数组关联的内存以防止内存泄漏。

我的理由是，如果类在数组中间某处构造元素时抛出异常，则该元素将无法正确构造，并且所有 future 元素都将因异常而停止构造，但之前的元素自从抛出异常之前就已经正确构造了。我想知道，在 catch (...) { } 中调用 delete 是个好主意吗？我将如何解决这个内存泄漏？

Badclass* array = nullptr;

try {
  array = new Badclass[10];  // May throw exceptions!
} catch (...) {
  delete[] array;
  array = nullptr;
  // set error flags
}

这是我在内存中形象化的方式。这是正确的吗？

 array         0    1    2    3   4    5 6 7 8 9
 ___          __________________________________
| ---------->| :) | :) | :) | :) | :( | | | | | |
|___|        |____|____|____|____|____|_|_|_|_|_|

Answer 1

回答最后一个问题:

How would I go about solving this memory leak?

没有内存泄漏。只有当 BadClass 本身动态分配内容并且从未在其析构函数中释放它时，才会发生泄漏。由于我们没有注意到您的 BadClass 实现，而不是猜测，这取决于您。 new BadClass[N]; 本身泄漏内存的唯一方法是，如果它完成并且您稍后丢弃您手动管理的唯一引用(array)。

一个动态分配的数组，在其中一个构造函数中抛出元素，将 (a) 以相反的顺序为已构造的元素退出析构函数，(b) 释放分配的内存，最后 (c) 执行实际的throw 到最近的 catch 处理程序(或没有的默认处理程序)。

因为发生了 throw，所以对结果数组指针的赋值永远不会发生，因此不需要 delete[]。

最好的例子:

#include <iostream>

struct A 
{
    static int count;
    int n;

    A() : n(++count)
    {
        std::cout << "constructing " << n << '\n';
        if (count >= 5)
            throw std::runtime_error("oops");
    }

    ~A()
    {
        std::cout << "destroying " << n << '\n';
    }
};

int A::count;

int main()
{
    A *ar = nullptr;
    try
    {
        ar = new A[10];
    }
    catch(std::exception const& ex)
    {
        std::cerr << ex.what() << '\n';
    }
}

输出

constructing 1
constructing 2
constructing 3
constructing 4
constructing 5
destroying 4
destroying 3
destroying 2
destroying 1
oops

请注意，由于元素“5”的构造从未完成，因此不会触发其析构函数。但是， 成功构造的成员 被破坏(在上面的示例中没有演示，但如果你愿意的话，这是一个有趣的练习)。

综上所述，无论如何都要使用智能指针。