Why can't arrays be passed as function arguments in C?

Question

Following this comment, I've tried to google why, but my google-fu failed.

Comment from link:

[...] But the important thing is that arrays and pointers are different things in C.

Assuming you're not using any compiler extensions, you can't generally pass an array itself to a function, but you can pass a pointer, and index a pointer as if it were an array.

You're effectively complaining that pointers have no length attached. You should be complaining that arrays can't be passed as function arguments, or that arrays degrade to pointers implicitly.

Answer 1

My first guess for the reason was simply because of performance and memory saving reasons, and for the ease of compiler implementation as well (especially for the kind of computers at the time when C was invented). Passing huge arrays "by value" seemed to have a huge impact at the stack, it needs a full array copy operation for each function call, and probably the compiler must be smarter to output the correct assembly code (though the last point is debatable). It would also be more difficult to treat dynamically allocated arrays the same way as statically allocated arrays (from the viewpoint of the language's syntax).

EDIT: after reading some parts from this link, I think the real reason (and the reason why arrays in structs are treated as value types, while sole arrays are not) is the backward compatibility to C's predecessor B. Here is the cite from Dennis Ritchie:

[...} The solution constituted the crucial jump in the evolutionary chain between typeless BCPL and typed C. It eliminated the materialization of the pointer in storage, and instead caused the creation of the pointer when the array name is mentioned in an expression. The rule, which survives in today's C, is that values of array type are converted, when they appear in expressions, into pointers to the first of the objects making up the array.

This invention enabled most existing B code to continue to work, despite the underlying shift in the language's semantics. [..]

Answer 2

A PDP minicomputer with only 8 kB of memory can't allocate a very large stack. So, on such a machine, one has to be careful in a language design (or evolution) to be able to minimize what needs to go on the stack for expected common subroutine call usage. C is still used today to program extremely memory constrained (a few kB) embedded systems, so the trade-off is usually a good one.

On a processor architecture which has very few registers, passing any array by pointer rather than by value more often allows a register to be used as a subroutine call optimization.

Answer 3

Expanding on Doc Brown's answer a bit...

In B, when you declared an array as

auto a[10];

the compiler would set aside an extra word to store an offset to the first element of the array (essentially a pointer):

   +–––+      +–––+
a: |   | –––> |   | a[0]
   +–––+      +––-+
              |   | a[1]
              +–––+
               ...
              +–––+
              |   | a[9]
              +–––+

The array subscript operation a[i] was defined as *(a + i); given the starting address stored in a, offset i words and dereference the result.

When he was designing C, Ritchie wanted to keep B's a[i] == *(a + i) array behavior, but he didn't want to set aside storage for that explicit pointer. When you declare an array in C as:

T a[10]; // for any type T

what you get in memory is:

   +–––+
a: |   | a[0]
   +–––+
   |   | a[1]
   +–––+
    ...
   +–––+
   |   | a[9]
   +–––+

No storage is set aside for a pointer to the first element. Instead, he came up with the rule that unless it is the operand of the sizeof, _Alignof, or the unary & operators, an expression of type ”N-element array of T" will converted, or "decay" to an expression of type "pointer to T" and its value will be the address of the first element of the array.

This way, a[i] == *(a + i) still works, without needing to actually store a pointer value anywhere. a is not a pointer, but under most circumstances evaluates to a pointer value (although you can use the subscript operator on a pointer variable as well).

The downside of this rule is that array expressions lose their array-ness under most circumstances, including when passed as function arguments.

This behavior is unique to arrays; structs use a different mechanism to compute member access.