"if you want to pass a reference to an object you always have to be explicit about it" How do you explain this then? void func (int arr[n]);

Similarly, how can you explain passing a function to a function, is this pass by value: void func (void f(void)); Of course not.

Those are both function declarations, not calls. When you call those then you pass a pointer to the array in the first case and a pointer to a function in the second case. In neither case it is call by reference.

__blackjack__‭ No, in the first case you pass the array object and in the second case the function. As per various rules of parameter decay, the compiler will implicitly adjust them to pointers. Just as for example Java will implicitly adjust an object passed as parameter to a reference - same thing.

Lundin‭ Sorry, I disagree. In the first case you specify an array, but that array is not actually passed to the function (i.e. the function doesn't get direct access to the object). Array decay makes that completely equivalent to directly pass a pointer, which is copied. The function always gets a copy of an object (in this case a pointer). If the array would be actually passed, you could use sizeof on the argument and get the size of the array, which you can't do since you get just a copy of a pointer. I concede that the syntax rules of C makes the distinction here murky, but the underlying mechanism is uniform: copy the argument (i.e. pass-by-value). The fact that the array decays into a pointer is something that happens before the argument is actually passed.

Lundin‭ Moreover your example of a "function passed by reference" is not relevant, since functions in C are not objects (they are not first class values), so there is nothing to be passed except their pointers. That's true even in other contexts. Function identifiers represent pointers to the code of the function. Function pointers are also a different kind of beasts: you cannot modify a function using a pointer, they are intrinsically read only. So in a sense you could argue it is pass-by-reference, but actually it is only apparent, since the underlying mechanism is really pass-by-value (copy a pointer that happens to be a pointer to function), there is no special mechanism for functions.

Lorenzo Donati‭ A C++ reference does not pass the object to the function either. Array decay only makes arrays equivalent to pointers in the first dimension, int arr[n] decays to int*. But that is not true for int arr[x][y] which decays to int (*arr)[y], which is pretty much 100% equivalent to a C++ reference in every single aspect. C++ reference too are passed by value... unless the function is inlined behind the scenes. What it boils down to is how computers work, calling convention and ISA. And in a computer there is nothing called "pointer" or "reference", only addresses and direct vs indirect addressing. The terms "pointer" or "reference" otherwise have no universal or formal meaning outside a very specific programming language.

Lundin‭ Mmm. I admit that your multidimensional array example had me stumped and I have to think about it. Moreover, I agree that the terms "pointers" and "references" are language-specific. What I argued about is the term "pass-by-reference", which is (on the contrary) quite standard (albeit the implementations of the mechanism may vary). There is some merit in distinguishing between the two cases: what you specify in a call can be accessed directly by the function (call-by-reference) or not (call-by-value). In a call-by-reference situation the parameter inside the function is an alias for the actual argument passed to the function (how it is implemented is irrelevant to the terminology, although using machine addresses is probably the most common case). You may argue that a C++ reference is a pointer in disguise that is automatically dereferenced, but that's an implementation detail and the net effect is the same (you don't get to see the copy even if it happens under the hood).