Is call by reference and pass by reference same thing?

Answer 1

Strictly speaking there is no such term as call by value. Functions are called while parameters are passed. When someone uses the term call by value they really mean pass by value, so in that sense they are the same. However call by value is incorrect terminology.

Answer 2

Yes, they are the same thing -- both relate to how actual arguments are passed to a called function's formal arguments, with by value and by reference being the only two possibilities. The function determines which semantic to use.

All programming languages support pass by value, which means you pass the value of the object, not the object itself. That is, the function works on an exact copy of the object. Pass by reference is achieved by passing the address of an object. The address is actually passed by value, thus the address is copied, not the object residing at that address.

In C, pass by reference is achieved by declaring the function's formal argument as a pointer of the required type. Thus when you pass the address of an object, that address is copied to the formal argument. In C++, you can do the same thing, however C++ also supports the concept of references. A reference differs from a pointer in that a reference is not a variable (it has no storage of its own) it is simply an alias (an alternate name) for an existing object. As such a reference can never be null and cannot be reassigned once instantiated. In some respects, references act like constant pointers.

The following functions demonstrate the difference:

void byval (int i) { i*=2; }

void byref (int& i) { i*=2; }

void byptr (int* i) { *i *= 2; }

int main()

{

int x = 42;

byval (x);

byref (x);

byptr (&x);

}

The byval() function uses the pass by value semantic, thus we call by value. In other words, we pass the value of x (which is 42) and that value is assigned to the variable i. When we double i, x is left unchanged -- they are separate variables.

The byref() function uses the pass by reference semantic, thus we call by reference. That is, we pass the address of x, and that address is assigned to the reference i. When we double the value of i, we double the value of x -- they are the same variable by different names (aliases).

The byptr() function uses pass by value semantics, thus we call by value. That is, we pass the address of x by value, and that address is assigned to the pointer i. When we double the dereferenced value of i we double the value of x, since i points to x. That is, we get pass by reference semantics by passing addresses to pointers, by value.