将二维数组的第二个下标传递给函数时，它有什么用？

Question

In The C Programming Language , they have said that only the first dimension (subscript) of an array is free to be specified; second subscript must be specified:

If a two-dimensional array is to be passed to a function, the parameter declaration in the function must include the number of columns; the number of rows is irrelevant, since what is passed is, as before, a pointer to an array of rows, where each row is an array of 5 int s. In this particular case, it is a pointer to objects that are arrays of 5 int s. Thus if the array daytab is to be passed to a function f , the declaration of f would be:

 f(int daytab[][5]) { ... } 

More generally, only the first dimension (subscript) of an array is free; all the others have to be specified.

But in my programme, when I change the value of the second subscript (column), the programme still works the same. For instance, the programme

#include"stdio.h"
void arf(int[][2]); // I wrote 2 instead of 5
main() {
    int a[][5] = {{1,2,3,4,5}, {9,29,39,49,59}};
    arf(a);
}
void arf(int arr[][2]) {    //here too, changed the 2nd subscript
    size_t i;
    printf("%d", arr[0][4]);    //a[0][4] is 5
}

prints the output 5 , instead of a garbage value (my expectation).

Answer 1

I'm in two minds about whether it's advisable to discuss what is ultimately undefined behaviour. Here's a minimally modified version of the code in the question:

#include <stdio.h>

void arf(int arr[][2]);

int main(void)
{
    int a[][5] = { { 1, 2, 3, 4, 5 }, { 0, 9, 8, 7, 6 } };
    arf(a);
}

void arf(int arr[][2])
{
    printf("%d\n", arr[0][4]);
    printf("%d\n", arr[1][4]);
}

When compiled with GCC 7.3.0 on a Mac, I get:

$ gcc -o arr2d-13 arr2d-13.c
arr2d-13.c: In function ‘main’:
arr2d-13.c:8:9: warning: passing argument 1 of ‘arf’ from incompatible pointer type [-Wincompatible-pointer-types]
     arf(a);
         ^
arr2d-13.c:3:6: note: expected ‘int (*)[2]’ but argument is of type ‘int (*)[5]’
 void arf(int arr[][2]);
      ^~~
$

That alone should be enough to tell you that you're doing it wrong. I had to suppress my usual compilation flags; the code is not acceptable to me because it has that compiler warning. However, when run, the output is:

5
9

Why? Well, it is officially undefined behaviour, but …

The layout of the array in memory looks like:

╔═══╦═══╦═══╦═══╦═══╦═══╦═══╦═══╦═══╦═══╗
║ 1 ║ 2 ║ 3 ║ 4 ║ 5 ║ 0 ║ 9 ║ 8 ║ 7 ║ 6 ║
╚═══╩═══╩═══╩═══╩═══╩═══╩═══╩═══╩═══╩═══╝

When, despite its warnings, the array is passed to arf() , the function thinks that row 0 of the input array starts with the element containing 1 , and row 1 of the input array starts with the element containing 3 , and so on — because you told the compiler that the function takes an array with 2 elements per row.

When you misuse subscript 4 (the declaration of the argument says that the valid second subscripts are 0 and 1 ), then it adds 4 to the start address of the row, and ends up printing 5 in the first case; it prints 9 in the second case because the counting starts from the element containing 3 (0, 1, 2, 3, 4 elements later is the 9 ).

If your compiler wasn't warning you about the type mismatch, you need to get a better compiler. If your compiler was warning you about the type mismatch, you need to pay attention to your compiler. At this stage in your programming career, if the compiler deigns to warn you about your code, it has spotted a bug you need to fix. I still regard compiler warnings like that — and I normally compile with options to enforce my rule ( gcc -O3 -g -std=c11 -Wall -Wextra -Werror -Wmissing-prototypes -Wstrict-prototypes ) — but I've only been coding in C for nearly 35 years, so I know there's more for me to learn.

You also need to ensure you're compiling in C11 mode (the current standard), or in C99 (the old standard) — there is no real excuse for compiling in C90 (the archaic standard) or pre-standard modes. C99 said main() on its own is outdated because there is no return type. Always specify the return type explicitly, preferably using int main(void) when you ignore the argument list, or int main() if you insist (there are examples in the standard that use that notation).

Answer 2

The behavior of casting a multidimensional array to another array the same size but with different geometry is not undefined: the standard guarantees that the elements of a multidimensional array will be laid out contiguously, in row-major order.

If you want to get the compiler to change the geometry of the array, you can cast to a pointer of the desired dimensions and then dereference, as in:

int main(void)
{
  const int a[][5] = { { 1, 2, 3, 4, 5 }, { 0, 9, 8, 7, 6 } };
  arf(*(const int (*const)[][2])a);
}

The use of the other subscript, ie casting to an array of dimensions [5][2] (or [sizeof(a)/sizeof(int[2])][2] for a bit more resiliency) is to tell the compiler how many rows there are, so it can potentially catch bounds errors at compile time. In this specific example, where the information is just thrown away on the receiving end, that would not do you any good, but C also lets you declare a function prototype like void arf( const ptrdiff_t m, const ptrdiff_t n, const int a[m][n]) . C++ does not, but still lets you declare void arf(const int a[rows][cols]) , where rows and cols are constexpr values.

Note that you should always, always , always check your array bounds for overflows in C and C++.