Why was the static keyword used here?

Question

In standard C, you have a few options for declaring a function that accepts a pointer to a chunk of data:

void style_1(int * arr);

void style_2(int arr[]);

void style_3(int arr[10]);

void style_4(int size, int arr[size]);

void style_5(int arr[static 10]);

void style_6(int size, int arr[static size]);

The thing is, as near as I can tell, most of the "choice" is syntactic and doesn't contribute much to the program's actual meaning. The first three styles appear to be exactly equivalent, because "A declaration of a parameter as 'array of type' shall be adjusted to 'qualified pointer to type'" (C11 6.7.6.3 p7), and style_4 is also the same for the purposes of the pointer parameter. For both style_3 and style_4, the array size is thrown away.

style_5 and style_6 are actually different and impose a useful constraint, guaranteeing a non-null pointer with a minimum amount of storage. But why do we need to add a keyword to do this? The declarations of style_3 and style_4 seem to communicate just as much information to the reader. A compiler would surely have no problem with those, if only the language allowed them to be meaningful? As it is, this design choice seems to introduce a hole that can allow extra errors to slip through, by effectively instructing the machine not to check for them by default.

Why was static added to impose the size constraint on array parameters in C? Why is the size on its own not sufficient?

Answer 1

For historical reason, in C (and C++) a parameter whose type is written as "array of type T" is actually a "pointer to type T". So int arr [10] just looks like the parameter is an array, in reality it is an int*. The size information is lost.

In C, if you write int arr [static 10] this turns into an int* pointing to 10 elements. Which would allow the compiler to invoke undefined behaviour if your read or write arr[10] or warn you if you assign to arr[10] with a constant 10.

Answer 2

Styles 5 and 6 were only added fairly recently to the C language (in the last decade or so), while the other styles have existed since the beginning for almost 30 years now.

When making changes to the C language, the committee doing so is very reluctant give new meaning to existing syntactic constructs, because it might break some existing code that used to be valid and with well-defined behavior.

That is the reason why styles 5 and 6 were added for the feature of passing an array with a guaranteed minimum size, rather than re-use styles 3 and 4.