0

我有一个函数来分配一个二维数组，以便不消耗比我需要的更多的内存：

_>

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] ，我们正在访问未分配的内存，因此应用程序此时失败，并且无法捕获错误。

4

2 回答 2

4

在第二种方式中，如果第一种方式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
}
于 2013-01-08T22:33:19.803 回答
0

根本不要捕获异常，只需在函数展开时使用 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());
}
于 2013-01-08T22:55:48.463 回答