将两个二维动态分配数组等同

Question

我在这个函数中的for循环有问题，它接受一个矩阵“a”，用向量“b”替换第一列，获得一个新的矩阵“aa”并用“aa”进行计算，然后重复指令对于其他列（简而言之，它给出了线性方程组的解）：

double* solution(double** a, double* b, int n, double detA)
{
    double* sol = (double*)malloc((n) * sizeof(double));
    for (int k = 0; k < n; k++)
    {
        {
            double** aa = a;
            for (int i = 0; i < n; i++)
            {
                aa[i][k] = b[i];
            }
            sol[k] = (determinant(aa, n)) / detA;
        }
    }
    return sol;
}

第

double** aa = a;

行正确创建了一个等于“a”的矩阵“aa”，并且外部 for 循环的第一次运行（k=0 情况）也给出了正确的第一个解“sol[0]”。 问题是，当 k=1 的 for 循环开始时，它不会创建等于“a”的新矩阵“aa”，而是使用相同的矩阵并替换第一列。所以最后我有一个矩阵，所有列都等于“b”。

其余所有代码都工作正常。问题正是在这里。我认为当在 for 循环内部创建新矩阵“aa”时，它在每个循环结束时被销毁，并在每个循环开始时创建一个新矩阵。

我该怎么办？我可能会编写更长的代码以确保矩阵完全按照我想要的方式创建，但我更喜欢我编写的代码。

Answer 1

如果你的“数组”是一个指向

double

的指针的数组，那么你需要在每次迭代时分配新的：

double **arraydup(double **a, size_t n)
{
    double** aa = malloc(n * sizeof(*aa));
    if(aa)
    {
        for(size_t index = 0; index < n; index++)
        {
            aa[index] = malloc(n * sizeof(**aa));
            if(aa[index])
            {
                memcpy(aa[index], a[index], n * sizeof(**aa));
            }
            else
            {
                for(size_t freeIndex = 0; freeIndex < index; freeIndex++)
                    free(aa[index]);
                free(aa);
                aa = NULL;
                break;
            }
        }
    }
    return aa;
}

void freeArr(double **a, size_t n)
{
    if(a)
    {
        for(size_t index = 0; index < n; index++)
        {
            free(a[index]);
        }
        free(a);
    }
}



double* solution(double** a, double* b, size_t n, double detA)
{
    double* sol = malloc(n * sizeof(*sol));
    if(sol)
    {
        for (size_t k = 0; k < n; k++)
        {
            double** aa = arraydup(a, n);
            if(!aa) 
            {
                free(sol);
                sol = NULL;
                break;
            }
            for (size_t i = 0; i < n; i++)
            {
                aa[i][k] = b[i];
            }
            sol[k] = (determinant(aa, n)) / detA;
            freeArr(aa, n)
        }
    }
    return sol;
}