C 如何动态分配二维阵列，为什么？

对于我的任务，我必须在我的程序中做的一件事就是动态分配一个2D数组。 我不知道怎么做或者为什么

这就是我现在拥有的

   size = atoi(argv[1]);
   int Pond[size][size];
   int i, j;
   for(i = 0; i < size; i ++){
      for(j = 0; j < size; j++){
        Pond[i][j]=0;
      }
   }

size=atoi（argv[1]）；
内池[大小][大小]；
int i，j；
对于（i=0；i

我找到了这样做的答案，但我不知道如何访问每一列或每一行

int **Pond;
Pond = (int**)malloc(size * sizeof(int*));
for (i = 0; i < size; i++) {
    Pond[i] = (int *) malloc(size * sizeof(int));

int**Pond；
池塘=（int**）malloc（大小*sizeof（int*）；
对于（i=0；i

正确使用C强大的数组类型语法如下所示：

int (*Pond)[size] = malloc(size * sizeof(*Pond));

for(int y = 0; y < size; y++) {
    for(int x = 0; x < size; x++) {
        Pond[y][x] = 0;
    }
}

分配到此为止。在此之后，

Pond

中的元素可以像这样简单地访问：

int (*Pond)[size] = malloc(size * sizeof(*Pond));

for(int y = 0; y < size; y++) {
    for(int x = 0; x < size; x++) {
        Pond[y][x] = 0;
    }
}

---

它并没有变得更简单。

正确使用C强大的数组类型语法如下所示：

int (*Pond)[size] = malloc(size * sizeof(*Pond));

for(int y = 0; y < size; y++) {
    for(int x = 0; x < size; x++) {
        Pond[y][x] = 0;
    }
}

分配到此为止。在此之后，

Pond

中的元素可以像这样简单地访问：

int (*Pond)[size] = malloc(size * sizeof(*Pond));

for(int y = 0; y < size; y++) {
    for(int x = 0; x < size; x++) {
        Pond[y][x] = 0;
    }
}

---

它并没有变得更简单。

操作符作用于指针的方式与作用于数组表达式的方式几乎相同，因此无论如何分配，您都可以使用

Pond[i][j]

访问特定元素（除非您将其分配为dom0所示的1D数组）

如果在编译时知道行数和列数，这是最简单的：

#define M ... // rows
#define N ... // columns

int (*Pond)[N] = malloc ( sizeof *Pond * M);
...
Pond[i][j] = x;
...
free( Pond );

变量

Pond

的类型是“指向

N

-元素数组的

int

”。表达式

*Pond

的类型是“N-元素数组的

int

”因此，

sizeof*Pond

给出了

int

的

N

元素数组中的字节数；我们将其乘以

M

得到数组所需的总字节数

由于

a[i]

的计算结果为

*（a+i）

，因此

[]

运算符在指针表达式上的工作方式与在数组表达式1上的工作方式相同；也就是说，您可以在此处使用

Pond[i][j]

，就像在常规二维数组中一样

如果直到运行时才知道行数和列数，但您使用的是支持可变长度数组的C99编译器或C2011编译器，则大致相同：

size_t n, m;
/**
 * get values of n and m
 */
int (*Pond)[n] = malloc( sizeof *Pond * m );
...
Pond[i][j] = x;
...
free( Pond );

与上面的处理相同，只是

m

和

n

直到运行时才知道。在这两种情况下，动态分配的数组都是连续的（内存中的所有行都是相邻的）

但是因为

Pond[i][j]

被评估为

*（*（Pond+i）+j）

，所以它仍然有效

请注意，由于这是一个两步分配过程，因此解除分配还需要两步：

for ( size_t i = 0; i < m; i++ )
  free( Pond[i] );
free( Pond );

---

---

1.在大多数情况下，数组表达式将被转换或“衰减”为指针表达式，因此下标实际上以任何一种方式作用于指针表达式。

[]

运算符作用于指针的方式与作用于数组表达式的方式基本相同，因此您可以使用

Pond[i][j]

访问特定元素，而不考虑如何分配（除非如dom0所示将其分配为1D数组）

如果在编译时知道行数和列数，这是最简单的：

#define M ... // rows
#define N ... // columns

int (*Pond)[N] = malloc ( sizeof *Pond * M);
...
Pond[i][j] = x;
...
free( Pond );

变量

Pond

的类型是“指向

N

-元素数组的

int

”。表达式

*Pond

的类型是“N-元素数组的

int

”因此，

sizeof*Pond

给出了

int

的

N

元素数组中的字节数；我们将其乘以

M

得到数组所需的总字节数

由于

a[i]

的计算结果为

*（a+i）

，因此

[]

运算符在指针表达式上的工作方式与在数组表达式1上的工作方式相同；也就是说，您可以在此处使用

Pond[i][j]

，就像在常规二维数组中一样

如果直到运行时才知道行数和列数，但您使用的是支持可变长度数组的C99编译器或C2011编译器，则大致相同：

size_t n, m;
/**
 * get values of n and m
 */
int (*Pond)[n] = malloc( sizeof *Pond * m );
...
Pond[i][j] = x;
...
free( Pond );

与上面的处理相同，只是

m

和

n

直到运行时才知道。在这两种情况下，动态分配的数组都是连续的（内存中的所有行都是相邻的）

但是因为

Pond[i][j]

被评估为

*（*（Pond+i）+j）

，所以它仍然有效

请注意，由于这是一个两步分配过程，因此解除分配还需要两步：

for ( size_t i = 0; i < m; i++ )
  free( Pond[i] );
free( Pond );

---

---

1.在大多数情况下，数组表达式将被转换或“衰减”为指针表达式，因此下标实际上以任何一种方式处理指针表达式。

+1请注意，这需要C99编译器，因为

size

不是常量表达式。如果size相当小，则即使是

int-Pond[size][size]

就足够了。谢谢！这就是我一直在寻找的解决方案。你能告诉我为什么我必须动态分配吗？到目前为止，代码在没有malloc的情况下工作。数组在程序中不会改变大小。它确实会将数组传递给另一个函数，这就是我需要malloc的原因吗？很抱歉，我的评论发错了帖子。它已被删除。@ASMYLDO一个主要原因是，如果您尝试创建大型数组作为基于堆栈的对象，那么您会希望这样做。堆栈的大小通常非常有限（有时大约为1兆字节或2兆字节）。尝试创建一个2000 x 2000的大型整数数组（不使用

static

属性定义）函数内部。在大多数平台上，它可能会在运行时失败，因为堆栈将溢出。@MichaelPetch很公平，我假设这个问题的意思是“为什么我没有做全局/静态的”我使用的所有编译器上的witch都优先用于堆。无论如何，您是对的，它会带来一种危险，如果不破坏堆栈，就会严重扰乱它。尽管我将在尽可能多的“工厂重置”系统上尝试它