C 有人能解释一下这句话是怎么回事吗？

基本上我理解指针。但是当涉及到矩阵的动态分配时，也涉及到指针，我在这个过程中迷失了方向。我想知道如何翻译这段代码以理解它

(*a)[i] = (int*)malloc((*m) * sizeof(int));

读取矩阵的函数如下所示：

int n, m;
int **matrix;
reading(&n, &m, &matrix);

无效读取（int*n，int*m，int***a）{
int i，j；
printf（“n=”）；
扫描频率（“%d”和*n）；
printf（“m=”）；
扫描频率（“%d”和*m）；
（*a）=（int**）malloc（（*n）*sizeof（int*）；
对于（i=0；i<*n；i++）
（*a）[i]=（int*）malloc（（*m）*sizeof（int））；
对于（i=0；i<*n；i++）{
对于（j=0；j<*m；j++）{
printf（“a[%d][%d]=”，i，j）；
scanf（“%d”和（*a）[i][j]）；
}
}
}

---

以及声明中的

***a

的含义。我在大学里被告知，第一个星号代表动态分配，另外两个星号来自一个矩阵。对于向量，动态分配是

**v

等等。。。但我无法自然地在脑海中解释它，以便理解其中发生了什么。

您没有说明此函数是如何调用的，但大概它看起来是这样的：

int n, m;
int **matrix;
reading(&n, &m, &matrix);

因此在此上下文中，

矩阵

被定义为指向指针的指针。它可以保存

int*

数组的第一个元素的地址，每个元素都可以保存

int

数组的第一个元素的地址

当

&matrix

被传递到此函数时，您有一个指向指向指针的指针，这就是

reading

的参数

a

。在此上下文中，

a

包含指向调用函数中单个

int**

的指针，特别是

matrix

。通过在

reading

中取消引用

a

，您实际上是在调用函数中访问

矩阵

现在我们来看这一行：

(*a) = (int**)malloc((*n) * sizeof(int*));

这将为
*n
int*
数组分配空间，并将其分配给调用函数中的
*a
，（即
矩阵
。因此，现在您有了
int*
数组。现在：

for (i = 0; i < *n; i++)                     
    (*a)[i] = (int*)malloc((*m) * sizeof(int)); 

（i=0；i<*n；i++）的

（*a）[i]=（int*）malloc（（*m）*sizeof（int））；

这将循环通过
int*
数组的元素，并为每个元素分配一个指向足够容纳
*m
int
的内存块的指针

因此您现在实际上拥有了一个
int
的2D数组。但是请注意，这与实际的
int
2D数组不同，后者将声明为
int arr[n][m]
首先，您在一个函数中做了太多不同的事情，这使得它有点混乱。我建议您将逻辑从创建矩阵的逻辑中分离出来，以获得矩阵大小：

void get_大小（int*n，int*m）{
printf（“n=”）；
scanf（“%d”，n）；
printf（“m=”）；
scanf（“%d”，m）；
}
int**create_矩阵（int n，int m）{
int**matrix=malloc（n*sizeof（int*）；
对于（int i=0；i

从这里可以更容易地看到正在发生的事情，只需要更少的
*
s和
&
s

矩阵被实现为数组的数组，因此
int**matrix=malloc（n*sizeof（int*）；
为外部阵列分配内存，而
matrix[i]=malloc（m*sizeof（int））；
为每个内部数组分配内存。
首先让我回答您关于这一行的问题：

(*a)[i] = (int*)malloc((*m) * sizeof(int));

这样做的目的是分配一个精确的
*m
整数数组，并将指向该数组的指针保存到
*a
指向
int
的指针数组中，该数组以前分配为：

(*a) = (int**)malloc((*n) * sizeof(int*));

现在，如果仍然不清楚发生了什么，那么以更有意义的方式重新编写代码会有所帮助。为了简化工作，您可以使用临时变量，并将值分配给仅在函数末尾作为参数传递的指针。使用更有意义的名称也会有很大帮助

void read_matrix(int *rows, int *columns, int ***matrix) {
    int i, j, r, c;
    int **mat;

    printf("n = ");
    scanf("%d", &r);

    printf("m = ");
    scanf("%d", &c);

    // Allocate space for a matrix (i.e. an array of r integer pointers).
    mat = malloc(r * sizeof(int*));

    // Allocate space for each row of the matrix (i.e. r arrays of c integers).
    for (i = 0; i < r; i++)
        mat[i] = malloc(c * sizeof(int));

    for (i = 0; i < r; i++) {
        for (j = 0; j < c; j++) {
            printf("a[%d][%d] = ", i, j);
            scanf("%d", &mat[i][j]);
        }
    }

    *rows = r;
    *columns = c;
    *matrix = mat;
}

现在变成：

mat[i] = malloc(c * sizeof(int));

mat = malloc(r * sizeof(int*));

这更容易理解。这是为包含
c
整数的数组（矩阵的一行）分配空间

以前的情况是：

(*a)[i] = (int*)malloc((*m) * sizeof(int));

(*a) = (int**)malloc((*n) * sizeof(int*));

现在变成：

mat[i] = malloc(c * sizeof(int));

mat = malloc(r * sizeof(int*));

这是分配一个
r
整数指针数组（如果每个指针指向一行，则表示
r
行的矩阵）

。我将使用

x

引用调用方的

int**

（*a）=（int**）malloc（（*n）*sizeof（int*）；

设置调用方的指针（

x

）指向

*n

指向

int

的指针的空间。这是制作

*n

行矩阵的准备工作。内存将分配给每一行，我们将有一个指向该内存的指针，因此我们需要

n

指针

然后这些行：

for (i = 0; i < *n; i++)                     
    (*a)[i] = (int*)malloc((*m) * sizeof(int));

for (i = 0; i < *n; i++) {
    for (j = 0; j < *m; j++) {
        printf("a[%d][%d]=", i, j);
        scanf("%d", &(*a)[i][j]);
    }
}

---

通过

*m

数组设置

*n

的每个元素：对于每个元素

x[i][j]

（称为

（*a）[i][j]

，它传递元素的地址（

&（*a）[i][j]）

到

scanf

从输入流进行设置。

如果不知道

a

和

n

是什么，我很难准确说出发生了什么。听起来你需要