内存分配和 Try-Catch 块

Question

我有一个函数来分配一个二维数组，以免占用比我需要的更多的内存：

_>

template <class Xvar> Xvar** New2 (unsigned int rows,unsigned int cols)
{
    Xvar**  mem;
    unsigned int size, i;

    size = rows * cols;
    mem = new Xvar* [rows];
    mem [0] = new Xvar [size];
    for (i=1;i<rows;i++)
        mem [i] = &mem [0][i*cols];
    return mem;
}

现在，我需要检查该内存是否已分配。 （处理内存分配错误）， 不会降低功能的性能。

我应该为每个内存分配使用一个 try-catch 块，还是只为函数使用一个唯一的 try-catch 块。

template <class Xvar> Xvar** New2 (unsigned int rows,unsigned int cols)
{
    Xvar**  mem;
    unsigned int size, i;

    size = rows * cols;
    try {
    mem = new Xvar* [rows];
    }
    catch (...) { assert (...) } 
    try {
    mem [0] = new Xvar [size];
    } catch (...) { assert (...) }
    for (i=1;i<rows;i++)
        mem [i] = &mem [0][i*cols];
    return mem;
}

或类似的东西：

template <class Xvar> Xvar** New2 (unsigned int rows,unsigned int cols)
{
    try { 
    Xvar**  mem;
    unsigned int size, i;

    size = rows * cols;
    mem = new Xvar* [rows];
    mem [0] = new Xvar [size];
    for (i=1;i<rows;i++)
        mem [i] = &mem [0][i*cols];
    return mem;
     }catch  (...) { assert (...) }
}

我认为，不推荐第二种方式，因为如果第一种 new 失败，mem 为 NULL， 因此，如果我们执行 mem [0] ，我们正在访问未分配的内存，因此应用程序此时会失败，并且无法捕获错误。

Answer 1

在第二种方式中，如果第一个 new 失败，则评估立即跳转到 catch 块，甚至从不尝试访问 mem[0]。

在任何情况下，如果您想让分配失败并轻松检测到这一点，您可能应该使用nothrow 变体，如果分配失败，它只会返回NULL。所以像

mem = new (nothrow) Xvar*[rows];
if (!mem) {
    // allocation failed, do whatever you want
}
mem[0] = new (nothrow) Xvar[size];
if (!mem[0]) {
    // allocation failed, do whatever you want
}

Answer 2

根本不捕获异常，只需在函数展开时使用 RAII 清理内存：

template <class Xvar> Xvar** New2 (unsigned int rows,unsigned int cols)
{
    unsigned int size = rows * cols;
    std::unique_ptr<Xvar*[]> mem(new Xvar* [rows]);
    mem[0] = new Xvar [size];
    for (i=1; i<rows; i++)
        mem[i] = &mem[0][i*cols];
    return mem.release();
}

• 如果第一个 new 失败，则您的函数没有做任何事情并且没有泄漏任何内存：std::bad_alloc 被抛出，仅此而已
• 如果第二个失败，unique_ptr 析构函数会处理该内存，所以你再次没事。
• 接下来的三行不能抛出，所以不会导致第二个分配泄漏

---

正如 GmanNickG 指出的那样，这仍然是糟糕的代码。这是您要求的糟糕代码，但我不想给人留下我认可原始设计的印象。我不。太可怕了。

一旦调用者成功获取了他们的Xvar**，处理它的唯一方法是：

int **ii = New2<int>(x, y);
...
delete [] ii[0];
delete [] ii;

这是脆弱和令人不快的。两个更好的设计是：

1. 使用真正的矩阵/二维数组模板类来管理存储，并且可以按值返回。然后，当这个值对象超出范围时，内存将被回收

2. 使用带有自定义删除器的智能指针

   template <typename T> struct 2dDelete
   {
       void operator() (T **rows) {
           delete [] rows[0];
           delete [] rows;
       }
   };
   
   template <typename T>
   std::unique_ptr<T*[], 2dDelete<T>> 2dNew (unsigned rows, unsigned cols)
   {
       unsigned size = rows * cols;
       std::unique_ptr<Xvar*[]> tmp(new Xvar* [rows]);
       tmp[0] = new Xvar [size];
       for (i=1; i<rows; i++)
           tmp[i] = &tmp[0][i*cols];
       // hand-over from the intermediate pointer (which only owned the
       // top-level row allocation) to the caller's pointer (which will
       // own, and clean up, the whole thing).
       return std::unique_ptr<T*[], 2dDelete<T>> arr(mem.release());
   }