C Arrays – Why Does a C Array Decay to a Pointer When Passed with Size

arraysc++

I understand why an array decays to a pointer when passed to a function without specifying its size, eg.:

void test(int array[]);

Why does it do so when passed with the size? eg.

void test(int array[3]);

I am having trouble with sizeof under the latter function signature, which is frustrating as the array length is clearly known at compile time.

Best Answer

void test(int* array);
void test(int array[]);
void test(int array[3]);

All these variants are the same. C just lets you use alternative spellings but even the last variant explicitly annotated with an array size decays to a pointer to the first element.

That is, even with the last implementation you could call the function with an array of any size:

void test(char str[10]) { }

test("test"); // Works.
test("let's try something longer"); // Still works.

There is no magic solution, the most readable way to handle the problem is to either make a struct with the array + the size or simply pass the size as an additional parameter to the function.

LE: Please note that this conversion only applies to the first dimension of an array. When passed to a function, an int[3][3] gets converted to an int (*)[3], not int **.

Related Solutions

C++ Arrays – Understanding Array-to-Pointer Conversion (Decay)

It's said that arrays "decay" into pointers. A C++ array declared as int numbers [5] cannot be re-pointed, i.e. you can't say numbers = 0x5a5aff23. More importantly the term decay signifies loss of type and dimension; numbers decay into int* by losing the dimension information (count 5) and the type is not int [5] any more. Look here for cases where the decay doesn't happen.

If you're passing an array by value, what you're really doing is copying a pointer - a pointer to the array's first element is copied to the parameter (whose type should also be a pointer the array element's type). This works due to array's decaying nature; once decayed, sizeof no longer gives the complete array's size, because it essentially becomes a pointer. This is why it's preferred (among other reasons) to pass by reference or pointer.

Three ways to pass in an array¹:

void by_value(const T* array)   // const T array[] means the same
void by_pointer(const T (*array)[U])
void by_reference(const T (&array)[U])

The last two will give proper sizeof info, while the first one won't since the array argument has decayed to be assigned to the parameter.

^{1 The constant U should be known at compile-time.}

C – Exceptions to Array Decaying into a Pointer

Sure.

In C99 there are three fundamental cases, namely:

when it's the argument of the & (address-of) operator.
when it's the argument of the sizeof operator.
When it's a string literal of type char [N + 1] or a wide string literal of type wchar_t [N + 1] (N is the length of the string) which is used to initialize an array, as in char str[] = "foo"; or wchar_t wstr[] = L"foo";.

Furthermore, in C11, the newly introduced alignof operator doesn't let its array argument decay into a pointer either.

In C++, there are additional rules, for example, when it's passed by reference.

Best Answer

Related Solutions

C++ Arrays – Understanding Array-to-Pointer Conversion (Decay)

C – Exceptions to Array Decaying into a Pointer

Related Question