我可以在C99中使用数组作为函数参数吗？

Question

The C99 standard says the following in 6.7.5.3/7:

A declaration of a parameter as ''array of type'' shall be adjusted to ''qualified pointer to type'', where the type qualifiers (if any) are those specified within the [ and ] of the array type derivation.

Which I understand as:

void foo(int * arr) {} // valid
void foo(int arr[]) {} // invalid

However, gcc 4.7.3 will happily accept both function definitions, even when compiled with gcc -Wall -Werror -std=c99 -pedantic-errors . Since I am not a C expert, I am unsure if maybe I misinterpreted what the standard is saying.

I also noticed that

size_t foo(int arr[]) { return sizeof(arr); }

will always return sizeof(int *) instead of the array size, which firms my belief that int arr[] is handled as int * and gcc is just trying to make me feel more comfortable.

Can someone shed some light on this issue? Just for reference, this question arose from this comment .

Answer 1

Some context:

First of all, remember that when an expression of type "N-element array of T " appears in a context where it isn't the operand of the sizeof or unary & operator, or isn't a string literal being used to initialize another array in a declaration, it will be converted to an expression of type "pointer to T " and its value will be the address of the first element in the array.

That means when you pass an array argument to a function, the function will receive a pointer value as a parameter; the array expression is converted to a pointer type before the function is called.

That's all well and good, but why is arr[] allowed as a pointer declaration? I can't say that this is the reason for sure , but I suspect it's a holdover from the B language, from which C was derived. In fact, pretty much everything hinky or unintuitive about arrays in C is a holdover from B.

B was a "typeless" language; you didn't have different types for floats, integers, text, whatever. Everything was stored as fixed-size words, or "cells", and memory was treated as a linear array of cells. When you declared an array in B, as in

auto arr[10];

the compiler would set aside 10 cells for the array, and then set aside an additional 11th cell that would store an offset to the first element of the array, and that additional cell would be bound to the variable arr . As in C, array indexing in B was computed as *(arr + i) ; you'd take the value stored in arr , add an offset i , and dereference the result. Ritchie retained most of these semantics, with the huge exception of no longer setting aside storage for the pointer to the first element of the array; instead, that pointer value would be computed from the array expression itself when the code was translated. This is why array expressions are converted to pointer types, why &arr and arr give the same value, if different types (the address of the array and the address of the first element of the array are the same) and why an array expression cannot be the target of an assignment (there's nothing to assign to ; no storage has been set aside for a variable independent of the array elements).

Now here's the fun bit; in B, you'd declare a "pointer" as

auto ptr[];

This had the effect of allocating the cell to store the offset to the first element of the array and binding it to ptr , but ptr didn't point anywhere in particular; you could assign it to point to various locations. I suspect that notation was held over for a couple of reasons:

1. Most of the guys who worked on the initial version of C were familiar with it;
2. It sort of emphasizes that the parameter represents an array in the caller;

Personally, I would have preferred that Ritchie had used * to designate pointers everywhere, but he didn't (or, alternately, use [] to designate a pointer in all contexts, not just a function parameter declaration). I will normally recommend that everyone use * notation for function parameters instead of [] , simply because it more accurately conveys the type of the parameter, but I can understand why people would prefer the second notation.

Answer 2

Both your valid and invalid declarations are internally equivalent, ie, the compiler converts the latter to the former.

What your function sees is the pointer to the first element of the array.

PS. The alternative would be to push the whole array on the stack, which would be grossly inefficient from both time and space viewpoints.