c - 在c中获取二维数组的元素？

Question

我似乎无法从 c 中的二维数组中获取元素。这对我来说看起来很简单，但我想一个人看不到他的一个错误:P。我相信我的代码是正确的，尽管我收到了警告。

代码:

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

#define SIZE 2

int main() {
    int mat1[SIZE][SIZE] = {{2,3},{4,5}};
    int mat2[SIZE][SIZE] = {{6,7},{8,9}};

    int *res = multiply(mat1, mat2, SIZE);

    int i, j;
    for(i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            int getEl = *(*(res + i) + j);
            printf("%d ", getEl);
        }
        printf("\n");
    }
    return 0;
}

我得到的错误:

invalid type argument of unary '*' (have 'int')

我在这里没看到什么吗？

编辑:

抱歉各位，这是 .h 文件:

#define SIZE 2

int* multiply(int mat1[][SIZE], int mat2[][SIZE], int size) {
    int res[size][size];

    int i,j, k;
    for (i = 0; i < size; i++) {
        for (j = 0; j < size; j++) {
            int sumElement = 0;
            for (k = 0; k < size; k++) {
                sumElement += mat1[i][k]*mat2[k][j];
            }
            res[i][j] = sumElement;
            printf("sumElement: %d\n", sumElement);
        }
    }
    return &res;
}

我还必须补充一点，我在这里也定义了 SIZE，这似乎很不合逻辑。但我别无选择，因为我必须指定二维数组的大小。

Answer 1

C 中的函数不能直接返回矩阵，您必须使用双指针。一个数组，每个数组的指针对应于一行矩阵。

但是，这会给您的问题增加相当不必要的复杂性，并且需要将内存分配给返回的缓冲区，这是应该避免的事情(而且您不能返回指向局部变量的指针，它会崩溃)。

我认为对您来说最好的解决方案是根本不返回任何值。只需为 multiply() 提供一个可用于存储结果的缓冲区:

#define SIZE 2
void multiply(int res[SIZE][SIZE], int mat1[SIZE][SIZE], int mat2[SIZE][SIZE])
{
    int i, j, k, sumElement;
    for (i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            sumElement = 0;
            for (k = 0; k < SIZE; k++) {
                sumElement += mat1[i][k] * mat2[k][j];
            }
            res[i][j] = sumElement;
            printf("sumElement: %d\n", sumElement);
        }
    }
}

然后像这样使用函数:

int main()
{
    int mat1[SIZE][SIZE] = {{2,3},{4,5}};
    int mat2[SIZE][SIZE] = {{6,7},{8,9}};
    int res[SIZE][SIZE];

    multiply(res, mat1, mat2);

    int i, j;
    for(i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            int getEl = res[i][j];
            printf("%d ", getEl);
        }
        printf("\n");
    }
    return 0;
}

请注意，原生矩阵不是很通用，将其作为参数传递给其他函数可能会很棘手，因为该函数必须在编译时知道该矩阵的维度，否则它将无法工作。制作可以处理任何维度矩阵的函数的唯一方法是使用双指针。

回复评论:

要将它们转换为指向指针的指针并能够将任意大小的矩阵传递给您的函数并允许此函数也返回矩阵，您必须执行如下操作:

int** multiply(int** mat1, int** mat2, int size)
{
    int i, j, k;

    // allocate the memory necessary to store the results
    int** res = malloc(size * sizeof(int*));
    for (i = 0; i < size; ++i)
        res[i] = malloc(size * sizeof(int));

    // populate res with values
    for (i = 0; i < size; i++)
        for (j = 0; j < size; j++)
        {
            res[i][j] = 0;

            for (k = 0; k < size; k++)
                res[i][j] += mat1[i][k] * mat2[k][j];

            printf("sumElement: %d\n", res[i][j]);
        }

    return res;
}

现在这个函数可以处理任何大小的矩阵，自动分配存储结果所需的内存，并返回一个指针，您可以使用 res[i][j] 访问该指针。用法:

int main()
{
    int mat1[][SIZE] = { { 2, 3 }, { 4, 5 } };
    int mat2[][SIZE] = { { 6, 7 }, { 8, 9 } };

    // map them into double pointer matrixes so they can be used by multiply()
    int* pmat1[SIZE] = { mat1[0], mat1[1] };
    int* pmat2[SIZE] = { mat2[0], mat2[1] };

    int** res = multiply(pmat1, pmat2, SIZE);

    int i, j;
    for(i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            int getEl = res[i][j];
            printf("%d ", getEl);
        }
        printf("\n");
    }
    return 0;
}

这段代码只有一个问题，分配在同一函数结束前不会释放的内存被认为是不好的做法。相反，main() 应该分配 res 使用的内存，并将此缓冲区传递给 multiply() 使用，并负责释放使用后的此内存。不释放不再需要的内存是一个称为 memory leak 的问题.阅读维基百科文章了解详情。

在这样一个简单的代码中，程序在计算矩阵后不久就会终止，这并不重要，但您应该在未来的项目中牢记这一点。

更新 2:

这是一种方法:

void multiply(int** res, int** mat1, int** mat2, int size)
{
    int i, j, k;

    // populate res with values
    for (i = 0; i < size; i++)
        for (j = 0; j < size; j++)
        {
            res[i][j] = 0;

            for (k = 0; k < size; k++)
                res[i][j] += mat1[i][k] * mat2[k][j];

            printf("sumElement: %d\n", res[i][j]);
        }
}

int main()
{
    int mat1[][SIZE] = { { 2, 3 }, { 4, 5 } };
    int mat2[][SIZE] = { { 6, 7 }, { 8, 9 } };
    int res[][SIZE]  = { { 0, 0 }, { 0, 0 } };

    // map them into double pointer matrixes so they can be used by multiply()
    int* pmat1[SIZE] = { mat1[0], mat1[1] };
    int* pmat2[SIZE] = { mat2[0], mat2[1] };
    int* pres[SIZE]  = { res[0],  res[1] };

    multiply(pres, pmat1, pmat2, SIZE);

    int i, j;
    for(i = 0; i < SIZE; i++) {
        for (j = 0; j < SIZE; j++) {
            int getEl = res[i][j];
            printf("%d ", getEl);
        }
        printf("\n");
    }
    return 0;
}