Why don't pointer to VLA function parameters deduce their size automatically and is there currently any good usage of them?

Question

As I understand it every VLA have an hidden variable of it's size which value can be 'acquired' by sizeof operator. What I don't get here is pointer to VLA's used in function parameters - why isn't their size automatically deduced and stored in this hidden variable - why we should explicitly provide it. And in this case why should we even use it given that we have already the type 'pointer to array of unknown size'?

What I mean is this:

void func(size_t, int (*)[*]); //function accepting pointer to VLA

void func_1(size_t, int (*)[]); //function accepting pointer to array of unknown bound

void func(size_t sz, int (*parr)[sz]) //implementation of 'func'
{
    printf("%lu", sizeof(*parr) / sizeof(int));

    printf("%lu", sz);
}

void func_1(size_t sz, int(*parr)[]) //implementation of 'func_1'
{
    //printf("%lu", sizeof(*parr) / sizeof(int)); //error: invalid application of 'sizeof' to an incomplete type 'int []'

    printf("%lu", sz);
}

As I can see it the only benefit of using 'func' instead of 'func_1' is that 'sizeof' operator will return a copy of the initial value of 'sz'.

Example usages of the above functions:

int main()
{
    size_t sz = 3;

    int arr[sz];

    func(sizeof(arr) / sizeof(int), &arr);

    func_1(sizeof(arr) / sizeof(int), &arr);

    return 0;
}

Why can't the size of pointer to VLA parameter be assigned implicitly? This would at least make some good use of the syntax:

void func(int (*parr)[*]) // size copied from function argument
{
    printf("%lu", sizeof(*parr) / sizeof(int));

    printf("%lu", sz);
}

And then calling the function like this:

int main()
{
    size_t sz = 3;

    int arr[sz];

    func(&arr);

    return 0;
}

Will cause array hidden size variable with value of '3' to be passed as hidden argument to 'func' creating code similar to instancing previous 'func' with current syntax and using 'sizeof' operator to passed array.

If you're curios enough compiling the proposed syntax into whatever Clang compiler - you'll get an easter egg (;.

Answer 1

The size of a variable-length array (VLA) is associated with the type, not with an object.

For example, given:

size_t n = 41;
int vla[n+1];
printf("sizeof vla = %zu\n", sizeof vla);

the compiler creates an anonymous object initialized to n+1, which I'll call _anon, and defines a type int[_anon], which is the type of the array object vla. (Note that changing the value of n later does not change the value of _anon or the size of the VLA type).

You could also write:

size_t n = 41;
typedef int vla_t[n+1];
vla_t vla;

Applying sizeof to an expression (which, in this case, happens to be an object name) yields the size of that expression's type.

Inside func, the type of vla is not visible, so there's no way to get its size. parr is a pointer to an array of int of unspecified size. The types int[] (an array of unspecified size) and int[n+1] (a variable-length array of length n+1)` are compatible, but not the same type.

Answer 2

The length of a variable-length array is only known locally (as it must be, in order to stack-allocate the storage and to provide sizeof semantics). When it's passed to a function, it's just a regular array type, so the size has to be explicitly passed.

Answer 3

In a nasty horrible kludge which should have been abolished decades ago, but is relied upon by too much code to be done away with now, C compilers regarded all function parameters of array types as being equivalent to parameters of pointers-to-element type, whether the array size was specified or not.

There would probably not be any major technical difficulties with defining a syntax by which a function could be passed arrays of arbitrary size and automatically know how big they are. Unfortunately:

1. Passing arrays to functions presently means passing a pointer to the first element; adding a new syntax where it means something else would create more confusion than it resolves.

2. If existing code receives a pointer and an integer, and regards that pointer as identifying the first element of an array of a specified length, passing that "array" to a method which expects a "new-style" array could be tricky.

The second problem might be overcome by adding a syntax to turn a pointer/length combo into an "known-size array" that could be passed to methods that accept such things. The former problem, however, will probably be unsolvable unless or until C is replaced with a language which isn't focused on pointer "optimizations" which aren't even relevant anymore.