When two-dimensional array and multidimensional array as function parameters in C language [duplicate]

Answer 1

Arrays (both one and multidimensional) in c reside in continuous memory blocks. This means that when you define char a[3], the array is laid out in memory like this (forgive my terrible ascii art skills):

| a[0] | a[1] | a[2] |

For a two-dimensional array char a[2][3], the layout is like this:

| a[0][0] | a[0][1] | a[0][2] | a[1][0] | a[1][1] | a[1][2] |  
                              ^
                              +--- first row ends here

Therefore, when you index into a two-dimensional array a[i][j], the compiler generates code equivalent to this:

*(a + i*3 + j)

Which can be read as "skip i rows and take cell j in that row". To accomplish this, the compiler must know the length of the row (which is the second dimension). This means that the second dimension is a part of the type definition!

As such when you want pass a 2d array into a function, you must specify the needed dimension for the type definition.

Answer 2

Here is a quite good explaintation: http://www.eskimo.com/~scs/cclass/int/sx9a.html

Answer 3

Without the second dimension to the array the compiler doesn't know how to index into it. This is because the compiler does some arithmetic with a pointer to work out where to find the value in memory.

Answer 4

Arrays in C are quite "weak", and typically represented at run-time by just a pointer to the first element. When you declare something like int a[][], it's not possible to know how to compute the address of each element, since the type declaration doesn't say. This is why it won't compile, since the type is invalid.

If you could have int a[][], and then called it passing either int big[8][8] or int small[2][2], there's no way for the code inside the function to magically "adapt" for the proper address computation for these different arrays. This is why it won't work.

You can write a general function like int *matrix, size_t width and do the address computation manually, i.e. element "matrix[i][j]" is at matrix[i * width + j] for a row-major ordering.

Answer 5

Recent (e.g. C2011, and perhaps C99) C standards enable variable length array so the following function does work

int
sum (int n, int t[n][n])
{
  int s = 0;
  for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
      s += t[i][j];
  return s;
}   

^{this is compiled without warnings with gcc-4.7 -std=gnu99 -Wall -O -c ex.c and the generated assembler is what you expect}

As to why int t[][] cannot work, it is because each element of the entire t would be of type int [] which has indeterminate size.