What is difference between call by value and pass by value?

Answer 1

When you pass by value, the function's parameter is assigned the value of the argument that was passed. When you pass by reference, the function's reference parameter is assigned the address of the argument. In other words, pass by value copies the value, pass by reference passes the variable itself.

Pass by reference is always the preferred method of passing arguments to functions when those arguments are complex objects. If the argument is a primitive data type then the cost in copying the value is minimal, but copying a complex object is expensive in terms of performance and memory consumption. If the function parameter is declare constant, you can be assured the object's immutable members will not be affected by the function. If it is non-constant and you do not wish your object to be altered, you can either copy the object and pass the copy, or pass the object by value if the function is overloaded to cater for this eventuality (good code will provide both options).

Answer 2

"Call by value" and "pass by value" are two terms for the same thing - the passing of data to a function by copying its value.

(If you meant to ask "call by value" vs "call by reference", the latter means to pass data to a function by copying its address, making the original copy of the data ultimately available to the function.)

"Call by value" refers more how the function was called given the way its parameters were provided. "Pass by value" refers more to the data in the function's parameter. Take the following code:
int my_a;
my_a = 5;
foo(a);

The function foo is "called by value" and the integer parameter to foo() is "passed by value". At the end of the day, these two terms mean the same thing, the difference is whether you are looking from the point of view of the function call, or from the point of view of the parameters inside the function.

Answer 3

Pass by value and pass by reference are the two semantics by which data can be passed to a function. The arguments expected of a function are known as the formal arguments while the arguments being passed to the function are known as the actual arguments. The formal and actual arguments are independent of each other, so changing the value of a formal argument has no effect whatsoever upon the value of the actual argument.

When we pass an actual argument, the value of that argument is assigned to the corresponding formal argument using the built-in or user-defined copy method associated with the object being passed. This is known as pass by value and is the only mechanism by which arguments can actually be passed to functions.

However, if the formal argument is a pointer or reference type, the value we pass is actually a memory address and this enables the pass by reference semantic. That is, the function's formal argument can indirectly refer to the object identified by the actual argument, thus allowing objects to cross scopes. This is useful when an object's length (in bytes) is greater than that of a pointer because copying objects larger than a pointer can be an expensive operation.

For instance, if we have an array containing a million complex objects, it would be impractical to pass that array by value because every object would have to be copied. But if we pass the address of the array, we only need to copy the address, not the array itself. Of course we also need to pass the length of the array through a separate argument because an address alone does not specify whether that address refers to just one object or to a million objects. Object oriented languages get around this problem by encapsulating an array and its length as a self-contained object, thus we only need to supply the address of the object. Objects also encapsulate highly efficient move semantics in addition to copy semantics, thus making it possible to efficiently move complex objects to and from functions by value rather than by reference.

Answer 4

The best way to understand this is to use a programming language in which you can pass by either value or reference.

When you pass by value, the parameter as the function uses it is a copy of the parameter that the calling function had.

When you pass by reference, the parameter is actually an address in memory where something is. The function can either read this something, or it can also modify it.

Answer 5

Pass by value and pass by reference apply to functions that accept formal arguments. A formal argument may be a value or a reference. The function's caller uses actual arguments and the calling convention determines how an actual argument is assigned to the corresponding formal argument.

If the formal argument is a value, then the value of the actual argument is assigned to the formal argument.

If the formal argument is a reference, then the address of the actual argument is assigned to the formal argument.

The nett effect is that when you pass by reference, both the formal and actual arguments refer to the same object. Whereas when you pass by value, the formal argument is a copy of the actual argument.

Some languages, like C, do not support the notion of a reference argument and only use pass by value semantics. However, C does support the notion of a pointer data type which is a variable that can store a memory address. The value of a pointer is therefore a reference and passing a pointer by value is the same as passing by reference. This is because when a pointer value is assigned to another pointer, the address (the value of the pointer) is copied, thus the two pointers refer to the same object.

C++ evolved from C and uses the same pass by value semantic by default. However, C++ also has a dedicated reference type that allows native pass by reference semantics. A reference differs from a pointer in that a pointer is a variable and therefore requires memory of its own to store the address it refers to. Thus a pointer has an address and a value, just like any other variable. But a reference does not have its own address because a reference is simply an alias, an alternate name for an object in memory. In other words, the address of a reference is the address of the object it actually refers to, in the same way that Billy could be alternate name for an object named William; they are one and the same object by different names. A pointer is not an alias, it is a completely separate object. Another key difference is that a reference cannot be reassigned, it must be initialised at the point of declaration. In this respect it is similar to the behaviour of constant pointer. Finally, a reference can never refer to a non-existent object, whereas a pointer can. When a pointer is no longer required it must be nullified by assigning it the value zero.