Difference between Call by Value and Call by Reference

In programming languages, functions can be invoked in two ways: which is known as Call by Value and Call by Reference.

What is Call by Value method?

Call by value method copies the value of an argument into the formal parameter of that function. Therefore, changes made to the parameter of the main function do not affect the argument.

In this parameter passing method, values of actual parameters are copied to function’s formal parameters, and the parameters are stored in different memory locations. So any changes made inside functions are not reflected in actual parameters of the caller.

What is Call by Reference method?

Call by reference method copies the address of an argument into the formal parameter. In this method, the address is used to access the actual argument used in the function call. It means that changes made in the parameter alter the passing argument.

In this method, the memory allocation is the same as the actual parameters. All the operation in the function are performed on the value stored at the address of the actual parameter, and the modified value will be stored at the same address.

C Code Example of a Call by Value method

void main() {
        int a = 10,
        void increment(int);
        Cout << "before function calling" << a;
        increment(a);
        Cout << "after function calling" << a;
        getch();

        void increment(int x) {
            int x = x + 1;
            Cout << "value is" << x;
        }

Output:

before function calling 10
value is 11
after function calling 1-0

Because variable declared ‘a’in main() is different from variable ‘x’ in increment(). In this programme only variable names are similar, but their memory address are different and stored in different memory locations.

Java Code Example of a Call by Reference method

Public static void main(string args[]) {
    int a = 10;
    System.out.println("Before call Value of a = ", a);
    Void increment();
    System.out.println("After call Value of a = ", a);
}

Void increment(int x) {
    int x = x + 1;
}

Output:

Before call Value of a =10
After call Value of a =11

Because variable declared ‘a’ in is referencing/ pointing to variable ‘a’ in main(). Here variable name is different, but both are pointing/referencing to same memory address locations.

Call by Value vs. Call by Reference

Advantages of using Call by value method in C

Pros/benefits of a call by value in C:

• The method doesn’t change the original variable, so it is preserving data.
• Whenever a function is called it, never affect the actual contents of the actual arguments.
• Value of actual arguments passed to the formal arguments, so any changes made in the formal argument does not affect the real cases.

Advantages of using Call by reference method

Pros of using call by reference method:

• The function can change the value of the argument, which is quite useful.
• It does not create duplicate data for holding only one value which helps you to save memory space.
• In this method, there is no copy of the argument made. Therefore it is processed very fast.
• Helps you to avoid changes done by mistake
• A person reading the code never knows that the value can be modified in the function.

Disadvantages of using Call by value method

Here, are major cons/drawbacks of a call by value method:

• Changes to actual parameters can also modify corresponding argument variables
• In this method, arguments must be variables.
• You can’t directly change a variable in a function body.
• Sometime argument can be complex expressions
• There are two copies created for the same variable which is not memory efficient.

Disadvantages of using Call by reference method

Here, are major cons of using call by reference method:

• Strong non-null guarantee. A function taking in a reference need to make sure that the input is non-null. Therefore, null check need not be made.
• Passing by reference makes the function not pure theoretically.
• A lifetime guarantee is a big issue with references. This is specifically dangerous when working with lambdas and multi-threaded programs.