How is 'pass by reference' implemented without actually passing an address to a function?

Question

I am well aware of the fact that in C and C++ everything is passed by value (even if that value is of reference type). I think (but I'm no expert there) the same is true for Java.

So, and that's why I include language-agnostic as a tag, in what language can I pass anything to a function without passing some value?

And if that exists, what does the mechanism look like? I thought hard about that, and I fail to come up with any mechanism that does not involve the passing of a value.

Even if the compiler optimizes in a way that I don't have a pointer/reference as a true variable in memory, it still has to calculate an address as an offset from the stack (frame) pointer - and pass that.

Anybody who could enlighten me?

Answer 1

From C perspective:

There are no references as a language level concept. Objects are referred to by pointing at them with pointers.

The value of a pointer is the address of the pointed object. Pointers are passed by value just like any other arguments. A pointed object is conceptually passed by reference.

---

At least from C++ perspective:

How is 'pass by reference' implemented [...] ?

Typically, by copying the address of the object.

... without actually passing an address to a function?

If a function invocation is expanded inline, there is no need to copy the address anywhere. Same applies to pointers too, because copies may be elided due to the as-if rule.

---

in what language can I pass anything to a function without passing some value?

Such language would have to have significantly difference concept of a function than C. There would have to be no stack frame push.

Function-like C pre-processor macros, as their name implies, are similar to functions, but their arguments are not passed around at runtime, because pre-processing happens before compilation.

On the other hand, you can have global variables. If you change the global state of the program, and call a function with no arguments, you have conceptually "passed the new global state to the function" without having passed any value.

Answer 2

At a machine-code level, "pass X by reference" is essentially "pass the address of X by value".

Answer 3

Pointers are values. Valuea ars values. Values have a unique identity, require storage.

References are not values. References have no identity. If we have:

int x=0;
int& y=x;
int& z=x;

both y and z are references to x, and they have no independent identity.

In comparison:

int x=0;
int* py=&x;
int* pz=&x;

both py and pz are pointers at x, and they have independent identity. You could modify py and not pz, you can get a size of them, you can memset them.

In some circumstances, at the machine code level, references are implemented the same way as pointers, except certain operations are never performed on them (like reaiming them).

But C++ is not defined in terms of machine code. It is defined innterms of the behaviour of an abstract machine. Compilers compile your code to operations on this abstract machine, which has no fixed calling convention (by the standard), no layout for references, no stack, no heap, etc. It then does arbitrary transformations on this that do not change the as-if behaviour (a common one is single assignment), rearranges things, and then at some point emits assembly/machine code that generates similar behaviour on the actual hardware you are running on.

Now the near universal way to compile C++ is the compilation unit/linker model, where functions are exported as symbols and a fixed ABI calling convention is provided for other compilation units to use them. Then at link stage the compilation units are connected together.

In those ABIs, references are passed as pointers.

Answer 4

How is 'pass by reference' implemented without actually passing an address to a function?

Within the context of the C languages, the short answers are:

• In C, it is not.
• In C++, a type followed by an ampersand (&) is a reference type. For instance, int& is a reference to an int. When passing an argument to a function that takes reference type, the object is truly passed by reference. (More on this in the scholarly link below.)

But in truth, most of the confusion is semantics. Some of the confusion could be helped by:

• 1) Stop using the word emulated to describe passing an address.
• 2) Stop using the word reference to describe address

Or

• 3) Recognize that within the context of the C/C++ languages, in the phrase pass-by-reference, the word reference is defined as: value of address.

Beyond this, there are many examples of illusions and concepts created to convey impossible ideas. The concept of non-emulated pass-by-reference is arguably one of them, no matter how many scholarly papers or practical discussions.

This one (scholarly paper category) is yet another that presents a distinction between emulated and actual pass-by-reference in a discussion using both C & C++, but who's conclusions stick closely to reality. The following is an excerpt:

...Somehow, it is only a matter of how the concept of “passing by reference” is actually realized by a programming language: C implements this by using pointers and passing them by value to functions whereas C++ provides two implementations. From a side, it reuses the same mechanism derived from C (i.e., pointers + pass by value). On the other hand, C++ also provides a native “pass by reference” solution which makes use of the idea of reference types. Thus, even in C++ if you are passing a pointer à la C, you are not truly passing by reference, you are passing a pointer by value (that is, of course, unless you are passing a reference to a pointer! e.g., int*&). Because of this potential ambiguity in the term “pass by reference”, perhaps it’s best to only use it in the context of C++ when you are using a reference type.

But as you, and others have already noted, in the concept of passing anything via an argument, whether value or reference, that something must by definition have a value.

Answer 5

What is meant by pass by value is that the object itself is passed.

In pass by pointer, we pass the value of the pointer to the object.

In pass by reference, we pass a reference (basically a pointer that we know points to an object) in the same way.

So yes, we always pass a value, but the question is what is the value? Not always the object itself. But when we say pass a variable by **, we give the information relative to the object we want to pass, not the value actually passed.