C中矩阵行列式的求法

这是矩阵行列式的C代码，但它给出了编译错误

代码是：

#include<stdio.h>
#include<math.h>
int m;

float determinant(float b[][]);

int main(void)
{
int i,j,m;
printf("enter a no: ");
scanf("%d",&m);
//printf("%d",m);
float arr[m][m];
for(i=0;i<m;i++)
{
    for(j=0;j<m;j++)
    {
        scanf("%f",&arr[i][j]);
        //printf("%f",arr[i][j]);
    }
}


for(i=0;i<m;i++)
{
    for(j=0;j<m;j++)
    {
        printf("%f ",arr[i][j]);
    }

    printf("\n");
}



float det = determinant(arr);

printf("Determinant= %f ", det);




}

float determinant(float b[][])
{
int i,j;
int p;
float sum = 0;
float c[m][m];

for(i=0;i<m;i++)
{
    for(j=0;j<m;j++)
    {
        printf("%f ",b[i][j]);
    }

    printf("\n");
}



if(m==2)
{
    printf("Determinant for m=2");
    sum = b[0][0]*b[1][1] - b[0][1]*b[1][0];
    return sum;
}

for(p=0;p<m;p++)
{
    int h = 0,k = 0;
    for(i=1;i<m;i++)
    {
        for( j=0;j<m;j++)
        {
            if(j==p)
                continue;
            c[h][k] = b[i][j];
            k++;
            if(k == m-1)
            {   
                h++;
                k = 0;
            }
        }
    }

    m=m-1;
    sum = sum + b[0][p]*pow(-1,p) * determinant(c);

}




return sum;
}

我认为错误在于二维数组的传递。当我将其作为指针传递时，它会给出警告，但不会出现错误，但不会给出正确的结果，因为在中，行列式总是为零。所以我猜数组不是只传递的，当我在函数行列式中打印它时，它也不会打印。

---

请帮助我，因为我在我的项目中遇到了这个问题。

您可以在C99（haccks指出的可变长度数组）中这样动态声明数组，但在早期版本中不能：

float arr[m][m];

因此，如果遇到问题，请为其声明一个指针和malloc内存：

float* arr = malloc(sizeof(float)*m*m);

此外，该定义将不起作用（在两种情况下）：

您需要在传递给函数的数组中定义列

如果如我所示声明并分配指针，则只需在函数中传递一个指针：

float determinant(float *b, int size); //here size is your row dimension, in this case equal to m

在函数内部，访问您的元素，如：

*(b + size*i + j) = value // equivalent to b[i][j];

在代码中

scanf("%d",&m);
//printf("%d",m);
float arr[m][m];

这里，arr是一个具有静态内存分配的2D数组，因此您不能在运行时读取m并像这样声明arr。

---

因此，如果您想动态定义数组，那么当您将函数的原型声明为

int foo(int arr[], int n);

然后编译器将其解释为

int foo(int (*arr), int n);  // and that's why you can omit the first dimension!

int foo(int (*arr)[col], int n);   

i、 您的函数期望第一个参数的类型为

int*

。类似地，当参数是多维数组时

int foo(int arr[][col], int n); // Only first dimension can be omitted. You need to specify the second dimension.   

然后编译器将其解释为

int foo(int (*arr), int n);  // and that's why you can omit the first dimension!

int foo(int (*arr)[col], int n);   

i、 您的函数期望第一个参数的类型为

int（*）[col]

（指向

int

数组的指针）。
由于在大多数情况下，当传递给函数时，数组名衰减为指向其第一个元素的指针，因此在您的情况下，

arr

将衰减为指向其第一个元素的指针，即第一行。因此，其类型将变为

float（*）[m]

。如果将函数参数声明为

float determinant(int m, float b[][m]);     

电话应该是这样的

float det = determinant(m, arr);

---

用显式边界声明数组

浮点b[m][m]

；编译器不理解

浮点b[][]

中的空边界（空边界仅适用于一维数组，原因在其他答案中解释）

所以你的行列式函数应该是这样的：

float determinant(int m, float b[m][m])
{
    ...
}

---

还有其他方法可以使代码正常工作，但我认为这种方法最接近您已有的方法。

我同意您不能使用数组初始化的这种语法，您可以使用

int *p=(int*)calloc(n*n,sizeof(float));

然后访问您的元素，如下所示：-

*(p+j+n*i);//for p[i][j] element

---

希望有帮助：）

您的答案可能重复错误。阅读有关可变长度数组的内容。是的，您可以。这就是所谓的可变长度数组。我尝试过这个方法，但不起作用，并给出了另一个错误“m”未声明？你能告诉我其他的解决办法吗