Question

我写了这样的代码：

        double *psi1 = multiplyscalar(
                            multiplyscalar(submatrix( multiplyscalar(I3, ttt2, 3, 3), multiplyscalar(multiply(teta0, teta0t, 3, 1, 1, 3), pow(*ttt, -1.5), 3, 3),3,3), 2, 3, 3)
                            ,(  (*multiply(A3t, mu, 1, m, m, 1))-( *multiply(multiply(multiply(transpose(mu, m, 1), G1, 1, m, m, m),transpose(G, m, m), 1, m, m, m), mu, 1,m,m,1) ) )
                            ,3
                            ,3
                   );

调用的函数与此类似：

static double* multiply(double A[], double B[], int ra, int ca, int rb, int cb){
if(ca != rb){
    hal.console->printf("\n multiplication error\n");
    return nullptr;
}
double* C = new double[ra*cb];
double sum = 0;
for(int i = 0; i < ra; ++i){
    for(int j=0; j<cb; j++){
        for(int x=0; x<ca; x++){
            sum += A[(i*ca)+x]*B[(x*cb)+j];
        }
        C[(i*cb)+j] = sum;
        sum = 0;
    }
}
return C;}

所以我有内存泄漏，因为那些返回的指针永远不会“擦除”。

之后有delete他们的方法吗？我知道单独进行每项操作都会绕过这个问题，但我正在寻找更优雅的解决方案？

Answer 1

返回一个合适的容器，例如一些std::vector（或您的class使用它）。另请阅读rule of five。

可能定义一个template函数（模板参数是大小，可能使用std::array）。

还要考虑智能指针（例如std::unique_ptr），避免使用明确的new和delete。

Answer 2

您还可以在数组周围创建一个类包装器，并删除析构函数中的指针。不是最优雅的方式，但它应该有效。

Answer 3

您可以将子表达式拆分为变量赋值，而不是嵌套函数调用5（！）深度，一直泄漏分配。

然后抛弃double[]并使用std::vector<double>，它将为您处理所有分配。

然后丢弃所有手写函数并使用强大的Linear Algebra Library，这可能会将某些函数公开为operator+和operator*等。 al，懒洋洋地评估结果。

释放动态内存

3 个答案: