无法访问 C 中二维数组的位置

Question

大家好，我一直在尝试解决C中的乘法问题。我遇到了在Integer数组中获取元素的问题。到目前为止，我只能访问数组a[]的第一行，但其他值都不好。这是代码片段，问题在matrixProduct方法中：

int fa,ca,fb,cb=0;
int main(){
    int A[20][20], B[20][20]. C[20][20];
    printf("Rows for A: ");
    scanf("%d",&fa);
    printf("nColumns for A: ");
    scanf("%d",&ca);
    printf("nRows for B: ");
    scanf("%d", &fb);
    printf("nColumns for B: ");
    scanf("%d",&cb);
    if (ca!=fb){
        printf("nOperation not available");
        return 0;
    }else{//Filling matrix A & B
        int i,j;
        for (i=0; i<fa; i++){
            for(j=0;j<ca;j++){
                printf("Element at position A[%d][%d]: ",i,j);
                scanf("%d",&A[i][j]);
            }
        }
        for (i=0; i<fb; i++){
            for(j=0;j<cb;j++){
                printf("Element at position B[%d][%d]: ",i,j);
                scanf("%d",&B[i][j]);
            }
        }
    }
    int k=productoMatriz(A,B);
    return 0;
}
//Parameters two matrixes A,B 
int matrixProduct(int A[fa][ca],int B[fb][cb]){
    int i,j,k=0;
    int C[20][20];
    for (i=0; i<fa; i++){
            for(j=0;j<cb;j++){
                C[i][j]=0;
            }
    }
    for(i=0;i<fa;i++){
        for(j=0;j<cb;j++){
                printf(" A [%d] [%d] = %dn",i,j,A[i][j]);//Problem is in here works
        //ok for the first row but then it doesnt!
            for(k=0;k<ca;k++){
        //C[i][j]=A[i][k]*B[k][j];
            }
        }
    }
    printf("nnC Matrix:n");
    for(i=0; i<fa; i++)
    for(j=0; j<cb; j++)
    {
    printf("%d  ",C[i][j]);
    if(j==cb-1)
        printf("nn");
    }
    return 0;
}

编辑

现在我已经将20的值更改为宏，并更改了matrixProduct中的参数，但现在我试图用类似的东西在主方法中返回C值，然后在其他方法中打印void printMatrix(int C[MAXSIZE][MAXSIZE](:

C[MAXSIZE][MAXSIZE]=matrixProduct(A,B);
printMatrix(C);

我又一次得到了错误的价值观。。。

Answer 1

问题就在这里：

int matrixProduct(int A[fa][ca],int B[fb][cb]){

您的函数原型需要int [fa][ca]和int [fb][cb]，但您传递的是int [20][20]和int [20][20]。这些是不同大小的对象，因此当您试图访问数组元素时，它会从错误的地址中提取。

一个二维数组的布局是每一行跟在下一行之后。所以如果你有int A[2][2]，它看起来是这样的：

|  0  |  1  |  2  |  3  |
 [0,0] [0,1] [1,0] [1,1]

类似地，如果你有int A[3][3]，它看起来像这样：

|  0  |  1  |  2  |  3  |  4  |  5  |  6  |  7  |  8  |
 [0,0] [0,1] [0,2] [1,0] [1,1] [1,2] [2,0] [2,1] [2,2]

在第一种情况下，[1,0]在第三个字节，而在第二种情况下它在第四个字节。

编辑：

针对您的编辑，这将不起作用：

C[MAXSIZE][MAXSIZE]=matrixProduct(A,B);

因为不能从函数返回数组。您需要做的是将2D数组C作为参数传递。因为数组是作为指向第一个元素的指针传递给函数的，所以对数组所做的更改会反映在函数之外。

Answer 2

问题是，您正在为可变大小的fa by ca和fb by cb数组传递一个固定大小的20乘20的数组。这是不允许的：接受数组的方式应该与声明数组的方式相同：

int matrixProduct(int A[20][20], int B[20][20])

否则，编译器将从内存中的错误位置访问数据，从而导致未定义的行为。

或者，您可以将main中A和B的声明移动到读取fa、ca、fb和cb之后的某个点，并以与在matrixProduct函数头中声明它们相同的方式声明它们。

此外，matrixProduct函数似乎缺少原型。你应该得到这样的警告。

Answer 3

其他答案可能会指出您的错误。但根据我的说法，

• 对于打印，您不需要返回函数
• 因此，应该使用void函数
• 您应该使用宏来指定数组的大小。因为当您想增加或减少数组的大小时，它会很方便
• 第一维度的大小可能不会写在原型和参数中。但第二个必须
• 只要有可能和有用的场合，尽量发挥作用
• 您想要return和0，这是可以的，但用于错误处理您应该选择另一个数字，如-1
• 尽可能避免全局变量为什么
• 我还建议在定义函数之前声明函数原型，因为若您编写了错误类型的变量或未命中，编译器会警告您
• 您可以使用该代码，但请检查您的错误

我试着改进你的代码

#include <stdio.h>
#define SIZE 20
void take_data(int a[][SIZE], int b[][SIZE], int fa,int ca, int fb, int cb);
void multiplication(int a[][SIZE],int b[][SIZE],int mult[][SIZE],int fa,int ca,int fb,int cb);
void display(int mult[][SIZE], int fa, int cb);
int main()
{
    int a[SIZE][SIZE], b[SIZE][SIZE], mult[SIZE][SIZE], fa, ca, fb, cb;
    printf("Enter rows and column for first matrix: ");
    scanf("%d%d", &fa, &ca);
    printf("Enter rows and column for second matrix: ");
    scanf("%d%d",&fb, &cb);
    /* If colum of first matrix in not equal to row of second matrix, asking user to enter the size of matrix again. */
    while (ca!=fb)
    {
        printf("Error! column of first matrix not equal to row of second.n");
        printf("Enter rows and column for first matrix: ");
        scanf("%d%d", &fa, &ca);
        printf("Enter rows and column for second matrix: ");
        scanf("%d%d",&fb, &cb);
    }
    take_data(a,b,fa,ca,fb,cb);  /* Function to take matices data */
    multiplication(a,b,mult,fa,ca,fb,cb); /* Function to multiply two matrices. */
    display(mult,fa,cb); /* Function to display resultant matrix after multiplication. */
    return 0;
}
void take_data(int a[][SIZE], int b[][SIZE], int fa,int ca, int fb, int cb)
{
    int i,j;
    printf("nEnter elements of matrix 1:n");
    for(i=0; i<fa; ++i)
        for(j=0; j<ca; ++j)
        {
            printf("Enter elements a%d%d: ",i+1,j+1);
            scanf("%d",&a[i][j]);
        }
    printf("nEnter elements of matrix 2:n");
    for(i=0; i<fb; ++i)
        for(j=0; j<cb; ++j)
        {
            printf("Enter elements b%d%d: ",i+1,j+1);
            scanf("%d",&b[i][j]);
        }
}
void multiplication(int a[][SIZE],int b[][SIZE],int mult[][SIZE],int fa,int ca,int fb,int cb)
{
    int i,j,k;
    /* Initializing elements of matrix mult to 0.*/
    for(i=0; i<fa; ++i)
        for(j=0; j<cb; ++j)
        {
            mult[i][j]=0;
        }
    /* Multiplying matrix a and b and storing in array mult. */
    for(i=0; i<fa; ++i)
        for(j=0; j<cb; ++j)
            for(k=0; k<ca; ++k)
            {
                mult[i][j]+=a[i][k]*b[k][j];
            }
}
void display(int mult[][SIZE], int fa, int cb)
{
    int i, j;
    printf("nOutput Matrix:n");
    for(i=0; i<fa; ++i)
        for(j=0; j<cb; ++j)
        {
            printf("%d  ",mult[i][j]);
            if(j==cb-1)
                printf("nn");
        }
}

我们需要使用malloc()来返回数组，不要忘记free。使用返回数组

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZE 20
void take_data(int a[][SIZE], int b[][SIZE], int fa,int ca, int fb, int cb);
int** multiplication(int a[][SIZE],int b[][SIZE],int fa,int ca,int fb,int cb);
void display(int fa, int cb, int** mult);
void free_mult(int **mult, int Rows);

int main()
{
    int a[SIZE][SIZE], b[SIZE][SIZE], fa, ca, fb, cb;
    int** mult;
    printf("Enter rows and column for first matrix: ");
    scanf("%d%d", &fa, &ca);
    printf("Enter rows and column for second matrix: ");
    scanf("%d%d",&fb, &cb);
    /* If colum of first matrix in not equal to row of second matrix, asking user to enter the size of matrix again. */
    while (ca!=fb)
    {
        printf("Error! column of first matrix not equal to row of second.n");
        printf("Enter rows and column for first matrix: ");
        scanf("%d%d", &fa, &ca);
        printf("Enter rows and column for second matrix: ");
        scanf("%d%d",&fb, &cb);
    }
    take_data(a,b,fa,ca,fb,cb);  /* Function to take matices data */
    mult = multiplication(a,b,fa,ca,fb,cb); /* Function to multiply two matrices. */
    display(fa,cb,mult); /* Function to display resultant matrix after multiplication. */
    free_mult(mult, fa);
    return 0;
}
void take_data(int a[][SIZE], int b[][SIZE], int fa,int ca, int fb, int cb)
{
    int i,j;
    printf("nEnter elements of matrix 1:n");
    for(i=0; i<fa; ++i)
        for(j=0; j<ca; ++j)
        {
            printf("Enter elements a%d%d: ",i+1,j+1);
            scanf("%d",&a[i][j]);
        }
    printf("nEnter elements of matrix 2:n");
    for(i=0; i<fb; ++i)
        for(j=0; j<cb; ++j)
        {
            printf("Enter elements b%d%d: ",i+1,j+1);
            scanf("%d",&b[i][j]);
        }
}
int** multiplication(int a[][SIZE],int b[][SIZE],int fa,int ca,int fb,int cb)
{
    int i,j,k;

    int **mult = (int **)malloc(fa * sizeof(int *));
    int row;
    // for each row allocate Cols ints
    for (row = 0; row < fa; row++) {
        mult[row] = (int *)malloc(fa * sizeof(int));
    }

    /* Initializing elements of matrix mult to 0.*/
    for(i=0; i<fa; ++i)
        for(j=0; j<cb; ++j)
        {
            mult[i][j]=0;
        }
    /* Multiplying matrix a and b and storing in array mult. */
    for(i=0; i<fa; ++i)
        for(j=0; j<cb; ++j)
            for(k=0; k<ca; ++k)
            {
                mult[i][j]+=a[i][k]*b[k][j];
            }
    return mult;
}
void display(int fa, int cb, int** mult)
{
    int i, j;
    printf("nOutput Matrix:n");
    for(i=0; i<fa; ++i)
        for(j=0; j<cb; ++j)
        {
            printf("%d  ",mult[i][j]);
            if(j==cb-1)
                printf("nn");
        }
}
void free_mult(int **mult, int Rows)
{
    int row;
    // first free each row
    for (row = 0; row < Rows; row++) {
        free(mult[row]);
    }
    // Eventually free the memory of the pointers to the rows
    free(mult);
}