C++, multidimensional array

Question

When a multidimensional array is passed to a function, why does C++ require all but the first dimension to be specified in parameter li

Answer 1

A better way to ask this is to ask why C++ doesn't require the first dimension to be specified.

The reason is that for all arrays, you can't pass arrays by value to a function. If you try to declare a function taking an array the compiler will adjust the declaration to the corresponding pointer type.

This means that it doesn't matter what dimension you specify as the dimension doesn't form part of the function signature.

For example, these all declare exactly the same function.

void f(int *p);
void f(int p[]);
void f(int p[10]);
void f(int p[100]);

When navigating the array pointed to by p in the function, the only information that the copmiler needs is the size of the array elements, i.e. sizeof(int) in this case.

For more complex arrays exactly the same holds. These are all the same:

void g(Type p[][10][20]);
void g(Type (*p)[10][20]);
void g(Type p[10][10][20]);
void g(Type p[99][10][20]);

But these are all different from:

void g(Type p[][5][20]);

because adjusting the dimension of anything other than the outer array dimension affects the size of (at least) the outer array's elements meaning that the pointer arithmetic for navigating the array would have to change.

Answer 2

In short: The compiler doesn't need the dimension, because a array decays to a pointer. But any additional dimension is needed by the compiler, to calculate the correct location in memory.

At first you need to know that an array in C/C++ is a linear continuous object in memory. Which is very efficient.

Because an array in C/C++ is a linear continuous object in memory, an array will decay to a pointer. Copying the complete array will be a waste of time and memory and is not requiered. A pointer is anything needed to go through the array. To go through the array you can take the increment-operator or any calculation which evaluates to a valid address in the array. You can set a delimiter in the array itself i.e. '\0' in a String, or pass the length to the function seperatley to tell your code where the end of the array is.

With multi-dimensional arrays the thing is a little bit more complicated. A multi-dimesional array is still only a linear continuous object in the memory! But the compiler needs the information about the additional dimensions to calculate to correct position in memory, imagine the following:

char array[10][10]; // 0 - 99

correct:

// formal argument tells your compiler, that each column is 10 elements long
funca(int array[10][10]) {
    // access to element 25 (2 * 10 + 4, the 10 is known through your formal argument, remember that an array is null based)
    array[2][3] = 'x'; 
}

wrong:

// formal argument tells your compiler, that ech colum is 5 elements long
funcb(int array[10][5]) {
    // access to element 15 (2 * 5 * + 4, the 5 is known through your formal argument, remember that an array is null based)
    array[2][3] = 'x'; 
}

A note (or warning): Arrays in Java, especiallay (irregular) multi-dimensional arrays are completely different.

Answer 3

If you refer to static allocation, this is simple. Because the blocks of memory are contiguous which means that the memory cells are one after each other and the compiler knows where the next cell is in memory.

For unidimensional array in memory looks like this:

http://cplusplus.com/doc/tutorial/arrays/arrays3.gif

For bidimensional array in memory looks like this:

http://i.msdn.microsoft.com/dynimg/IC506192.png

Answer 4

For example int a[n][m] is an array whose type is an int array of length m. In other words, the length of array is part of its type. And as for all function parameters, compiler need to know its type.

There is no such thing as multidimensional array in c++. It is just a syntax which looks like it. In int a[4] and int b[5] a and b are different types.