c++ - 内存分配的专用函数导致内存泄漏？

Question

大家好，

我认为以下代码会产生内存泄漏？

    /* External function to dynamically allocate a vector */
    template <class T>
            T *dvector(int n){
            T *v;

            v = (T *)malloc(n*sizeof(T));

            return v;
    }


    /* Function that calls DVECTOR and, after computation, frees it */
    void DiscontinuousGalerkin_Domain::computeFaceInviscidFluxes(){
            int e,f,n,p;
            double *Left_Conserved;

            Left_Conserved = dvector<double>(NumberOfProperties);

            //do stuff with Left_Conserved
            //

            free(Left_Conserved);

            return;
    }

我认为，通过将指针传递给 DVECTOR，它会分配它并返回正确的地址，这样 free(Left_Conserved) 就会成功解除分配。然而，似乎并非如此。

注意:我也测试过用 new/delete 替换 malloc/free 也没有成功。

我有一段类似的代码用于分配二维数组。我决定像这样管理 vector/数组，因为我经常使用它们，而且我还想了解更深入的 C++ 内存管理。

所以，我非常想保留一个外部函数来为我分配 vector 和数组。避免内存泄漏的问题是什么？

编辑

我也一直在使用 DVECTOR 函数来分配用户定义的类型，所以我猜这可能是个问题，因为我没有调用构造函数。

即使在我释放 Left_Conserved vector 之前的代码段中，我也想以其他方式分配一个 vector 并使其“打开”以供其他函数通过其指针进行评估。如果使用 BOOST，它会在函数结束时自动清理分配，所以，我不会用 BOOST 得到一个“公共(public)”数组，对吧？我想这很容易用 NEW 解决，但是对于矩阵来说什么是更好的方法？

我刚刚想到我将指针作为参数传递给其他函数。现在，BOOST 似乎不太喜欢它，并且编译退出并出现错误。

所以，我坚持需要一个指向 vector 或矩阵的指针，它接受用户定义的类型，将作为参数传递给其他函数。 vector (或矩阵)很可能在外部函数中分配，并在另一个合适的函数中释放。 (我只是不想在代码中到处复制循环和用于分配矩阵的新内容!)

这是我想做的:

    template <class T>
    T **dmatrix(int m, int n){
            T **A;

            A = (T **)malloc(m*sizeof(T *));
            A[0] = (T *)malloc(m*n*sizeof(T));

            for(int i=1;i<m;i++){
                    A[i] = A[i-1]+n;
            }

            return A;
    }


    void Element::setElement(int Ptot, int Qtot){

            double **MassMatrix;

            MassMatrix = dmatrix<myT>(Ptot,Qtot);

            FillInTheMatrix(MassMatrix);

            return;
    }

Answer 1

那里没有内存泄漏，但你应该使用 new/delete[] 而不是 malloc/free。特别是因为您的函数是模板化的。

如果您想使用具有非平凡构造函数的类型，那么基于 malloc 的函数就会被破坏，因为它不调用任何构造函数。

我将通过简单地执行此操作来替换“dvector”:

void DiscontinuousGalerkin_Domain::computeFaceInviscidFluxes(){
        double *Left_Conserved = new double[NumberOfProperties];

        //do stuff with Left_Conserved
        //

        delete[] Left_Conserved;
}

它在功能上是等价的(除了它可以为其他类型调用构造函数)。它更简单并且需要更少的代码。此外，每个 C++ 程序员都会立即知道发生了什么，因为它不涉及额外的功能。

更好的是，使用智能指针来完全避免内存泄漏:

void DiscontinuousGalerkin_Domain::computeFaceInviscidFluxes(){
        boost::scoped_array<double> Left_Conserved(new double[NumberOfProperties]);

        //do stuff with Left_Conserved
        //
}

正如许多聪明的程序员喜欢说的那样“最好的代码是您不必编写的代码”

编辑:为什么您认为您发布的代码会泄漏内存？

编辑:我看到你对另一篇文章的评论说

At code execution command top shows allocated memory growing indefinitely!

这可能完全正常(也可能不正常)，具体取决于您的分配模式。通常堆的工作方式是它们经常增长，但不经常收缩(这是为了有利于后续分配)。完全对称的分配和释放应该允许应用程序稳定在一定的使用量。

例如:

while(1) {
    free(malloc(100));
}

不应导致持续增长，因为堆很可能为每个 malloc 提供相同的 block 。

所以我的问题是。它是“无限期”增长还是根本不会收缩？

编辑:

您已询问如何处理二维数组。就个人而言，我会使用类来包装细节。我要么使用一个库(我相信 boost 有一个 n 维数组类)，要么使用你自己的库应该不会太难。这样的事情可能就足够了:

http://www.codef00.com/code/matrix.h

用法是这样的:

Matrix<int> m(2, 3);
m[1][2] = 10;

从技术上讲，使用 operator() 之类的方法来索引矩阵包装器类会更有效，但在这种情况下，我选择模拟 native 数组语法。如果效率真的很重要，它可以像原生数组一样高效。

编辑另一个问题。你在什么平台上开发？如果是 *nix，那么我会推荐 valgrind 来帮助查明内存泄漏。由于您提供的代码显然不是问题所在。

我不知道，但我确信 Windows 也有内存分析工具。

编辑:对于矩阵，如果您坚持使用普通的旧数组，为什么不将其分配为单个连续 block 并像这样对索引进行简单的数学运算:

T *const p = new T[width * height];

然后要访问一个元素，只需这样做:

p[y * width + x] = whatever;

通过这种方式，您可以对指针执行 delete[]，无论它是 1D 还是 2D 数组。