Difference Between Call By Value and Call by Reference

In C++ and Java, there are two ways to call a function or a method. The first is “call by value” and the second is “call by reference”. Call by value method passes only the value of a variable to the function code, and if there is any change in the value of a variable inside that function it does not affect the original value of that variable. In call by reference method, we pass the variable itself in an argument, and the change in the value of a variable also affects the original value of that variable. The main difference between both the methods is, call by value method passes the value of a variable  and call by reference passes the address of that variable.

Content: Call By Value Vs Call By Reference

1. Comparison Chart
2. Definition
3. Key Differences
4. Conclusion

Comparison Chart:

Basis for Comparison	Call_By_Value	Call By Reference
Basic	A copy of the variable is passed.	A variable itself is passed.
Effect	Change in a copy of variable doesn't modify the original value of variable out side the function.	Change in the variable affect the value of variable outside the function also.
Calling Parameters	function_name(variable_name1, variable_name2, . . . .);	function_name(&variable_name1, &variable_name2, . . . .); //in case of object object.func_name( object);
Receiving Parameters	type function_name(type variable_name1, type variable_name2, . . . .) { . . }	type function_name( type *variable_name1, type *variable_name2, . . . .){ . . } //in case of object type function_name(class_type object_name) { . . }
Default calling	primitive type are passed using "call by value".	objects are implicitly passed using "call by reference".

Definition of Call By Value

If you pass a primitive data type (integer, character, and string ) to a function/method, then only it’s “value” is passed to the function code. The function copies that value of an argument to a ‘formal parameter’ of the function code. If there is any modification to the formal parameter in a function code, it will not modify of the original value of the argument which is used to call that function.

In simple words, if a function/method is called by  ‘call by value’ approach; then a copy of the variable is passed to the function code. If a function code makes any changes to the value in the copy of the variable, it doesn’t change the original value of the variable.

Let’s see an example to understand this briefly.

//example in Java
class check{
void change( int i, int j){
i = i*i;
j = j/2;
system.out.println( "value of parameter inside the function");
system.out.println( " value of 'i' which accepts the value of argument 'a' " +i);
system.out.println( " value of 'j' which accepts the value of argument 'b' " +j);
}
}
class call_by _value{
public static void main(string args[]){
int a=12, b=20;
check C= new check();
system.out.println("value of 'a' and 'b' before function call" + a +"  " +b);
C.change(a,b); //call by value.
system.out.println("value of 'a' and 'b' after function call" + a +"  " +b);
}
}

//output
value of 'a' and 'b' before function call 12  20
value of parameter inside the function
value of 'i' which accepts the value of argument 'a'  144
value of 'j' which accepts the value of argument 'b'  10
value of 'a' and 'b' after function call  12  20

Definition of Call By Reference

Call by Reference method passes a reference/address of an argument to the function code. As the address of an argument is passed to the function code, the formal parameter accepting that address would be a ‘pointer’ variable. Now, as function code has obtained the address of an argument, the modification in the value of an argument will also modify the original value of an argument.

In C++ and Java, it is very common to pass the object to the function/method and object are always passed by its reference. Changes done to the object inside the function/method affects the object used to invoke that function/method.

Following fragment shows the correct way to ‘call by reference’.

//example in C++
class swap{
void swap( int *x, int*y){
int temp;
temp=*x;
*x=*y;
*Y=temp;
}
}
int main{
int a=10, b=20;
cout<<"value of a, b before the function call"<< a<< " "<<b;
swap S(&a, &b); //call by reference.
cout<<"value of a, b after the function call"<< a<< " "<<b;
}

//output
value of a, b before the function call 10 20
value of a, b after the function call 20 10

Now let’s discuss ‘call by reference’ by passing an ‘object’ as an argument, which is implicitly passed by the approach ‘call by reference’.

class check{
int a, b;
check( int x, int b){ // object initialized through this constrtuctor
a=x;
b=y;
}
void exchange(check ob){
ob.a= a*2;
ob.b= b/2;
}
}
class main_class{
public static void main(string args[ ]){
check C=new check(20,40); //object initialization.
system.out.println("value of 'ob.a' and 'ob.b' before function call" + ob.a +" " +ob.b);
C.exchange(C); //call by reference.
system.out.println("value of 'ob.a' and 'ob.b' before function call" + ob.a +" " +ob.b);
}
}

//output
value of 'ob.a' and 'ob.b' before function call 20 40
value of 'ob.a' and 'ob.b' after function call 40 20

Conclusion:

C++ and Java use both the approaches depending on what is passed. If you want to pass only the value of variable use’call by value’ approach and if you want to see the change in the original value of the variable then use ‘call by reference’ approach.