为什么我们在传递二维数组作为参数时需要指定列大小？

Question

为什么我的参数不能是

void example(int Array[][]){ /*statements*/}

为什么我需要指定数组的列大小？比如说，3

void example(int Array[][3]){/*statements*/}

我的教授说它是强制性的，但我在开学前就在编码，我记得当我把它作为参数时没有语法或语义错误？还是我错过了什么？

Answer 1

在描述参数时，数组总是衰减为指向其第一个元素的指针。

当您将声明为int Array[3] 的数组传递给函数void foo(int array[]) 时，它会衰减为指向数组开头的指针，即int *Array;。顺便说一句，您可以将参数描述为int array[3] 或int array[6] 甚至int *array - 所有这些都是等效的，您可以毫无问题地传递任何整数数组。

在数组数组（二维数组）的情况下，它也衰减为指向其第一个元素的指针，这恰好是一维数组，即我们得到int (*Array)[3]。

在此处指定大小很重要。例如，如果它不是强制性的，那么编译器将无法知道如何处理表达式Array[2][1]。

要取消引用编译器需要计算我们需要的项目在连续内存块中的偏移量（int Array[2][3] 是一个连续的整数块），这对于指针来说应该很容易。如果a 是指针，则a[N] 扩展为start_address_in_a + N * size_of_item_being_pointed_by_a。在函数内部的表达式Array[2][1]（我们要访问此元素）中，Array 是指向一维数组的指针，并且适用相同的公式。查找size_of_item_being_pointed_by_a 需要最后一个方括号中的字节数。如果我们只有Array[][]，就不可能找到它，因此不可能取消引用我们需要的数组元素。

如果没有大小，指针算法将不适用于数组数组。 Array + 2 会产生什么地址：将地址提前Array 2 个字节（错误）或将指针提前3* sizeof(int) * 2 字节？

Answer 2

在 C/C++ 中，即使是 2-D 数组也是按顺序存储的，在内存中一行接一行。所以，当你有（在一个单一的功能）：

int a[5][3];
int *head;

head = &a[0][0];
a[2][1] = 2; // <--

您实际使用a[2][1] 访问的元素是*(head + 2*3 + 1)，因为依次，该元素位于0 行的3 个元素和1 行的3 个元素之后，然后再进一步索引一个.

如果你声明这样的函数：

void some_function(int array[][]) {...}

从语法上讲，它不应该是一个错误。但是，当您现在尝试访问array[2][3] 时，您无法判断应该访问哪个元素。另一方面，当你有：

void some_function(int array[][5]) {...}

你知道array[2][3]，可以确定你实际上是在访问内存地址*(&array[0][0] + 2*5 + 3)处的元素因为函数知道第二维的大小。

还有另一个选项，如前所述，您可以声明如下函数：

void some_function(int *array, int cols) { ... }

因为这样，您调用函数时使用的“信息”与以前相同——列数。你访问数组元素的方式有点不同：你必须在通常写array[i][j]的地方写*(array + i*cols + j)，因为array现在是一个指向整数的指针（而不是指针）。

当您声明这样的函数时，您必须小心地使用实际为数组声明的列数调用它，而不仅仅是使用。所以，例如：

int main(){
   int a[5][5];
   int i, j;

   for (i = 0; i < 3; ++i){
       for (int j=0; j < 3; ++j){
           scanf("%d", &a[i][j]);
       }
   }

   some_function(&a[i][j], 5); // <- correct
   some_function(&a[i][j], 3); // <- wrong

   return 0;
}

Answer 3

C 2018 6.7.6.2 规定了数组声明符的语义，第 1 段对它们给出了约束，包括：

元素类型不能是不完整类型或函数类型。

在诸如void example(int Array[][]) 的函数声明中，Array[] 是一个数组声明符。所以它必须满足其元素类型不能不完整的约束。它在该声明中的元素类型是int []，由于未指定大小，因此不完整。

没有根本原因 C 标准不能删除对即将调整为指针的参数的约束。生成的类型int (*Array)[] 是一个合法声明，被编译器接受，并且可以以(*Array)[j] 的形式使用。

然而，声明int Array[][] 表明Array 至少与二维数组相关联，因此应以Array[i][j] 的形式使用。即使声明int Array[][]被接受并调整为int (*Array)[]，也无法将其用作Array[i][j]，因为下标运算符要求其指针操作数是指向完整类型的指针，而这一要求是不可避免的因为需要计算元素的地址。因此，保持对数组声明符的约束是有意义的，因为它与预期的表达式一致，即参数将是一个二维数组，而不仅仅是指向一个一维数组的指针。

Answer 4

实际上无论是二维数组还是一维数组，它都以一行的形式存储在内存中。所以说编译器应该在哪里断行，指示下一个数字在我们应该在下一行中提供列大小。并且适当地打破行将给出行的大小。

我们来看一个例子：

int a[][3]={ 1,2,3,4,5,6,7,8,9,0 };

这个数组a在内存中存储为：

  1  2  3  4  5  6  7  8  9  0

但由于我们将列大小指定为 3，内存会在每 3 个数字后拆分。

#include<stdio.h>

int main() {
   int a[][3]={1,2,3,4,5,6},i,j;
   for(i=0;i<2;i++)
   {
       for(j=0;j<3;j++)
       {
           printf("%d  ",a[i][j]);
       }
       printf("\n");
   }

}

输出：

 1  2  3  
 4  5  6  

在另一种情况下，

int a[3][]={1,2,3,4,5,6,7,8,9,0};

编译器只知道有3行，但不知道每行的元素个数，所以无法分配内存，会报错。

#include<stdio.h>

int main() {
   int a[3][]={1,2,3,4,5,6},i,j;
   for(i=0;i<3;i++)
   {
       for(j=0;j<2;j++)
       {
           printf("%d  ",a[i][j]);
       }
       printf("\n");
   }

}

输出：

 c: In function 'main':
    c:4:8: error: array type has incomplete element type 'int[]'
    int a[3][]={1,2,3,4,5,6},i,j;
        ^

Answer 5

关于这个有一个类似的帖子。你可以参考下面的链接。 Creating Array in C and passing pointer to said array to function 希望对您有所帮助。

另一方面，编译器需要第二维，以便将“数组”从一个指针移动到下一个指针，因为整个内存以线性方式排列

Answer 6

当您在内存中创建二维数组anytype a[3][4] 时，您实际创建的是3 4 anytype 对象的连续块。

a[0][0] a[0][1] a[0][2] a[0][3] a[1][0] a[1][1] a[1][2] a[1][3] a[2][0] a[2][1] a[2][2] a[2][3]

现在下一个问题是，为什么会这样？因为，与语言的规范和结构保持一致，anytype a[3][4] 实际上扩展为anytype (*a)[4]，因为数组衰减为指针。事实上，它也扩展到anytype (*(*a))，但是，您现在已经完全失去了二维数组的大小。所以，你必须帮助编译器。

如果您向程序询问a[2]，程序可以按照与一维数组完全相同的步骤进行操作。它可以简单地返回the 3rd element of sizeof(object pointed to)，这里指向的对象是大小为4的anytype对象。