Call by value and call by reference.

Call by Value

If data is passed by value, the data is copied from the variable used in for example main() to a variable used by the function. So if the data passed (that is stored in the function variable) is modified inside the function, the value is only changed in the variable used inside the function. Let’s take a look at a call by value example:

#include <stdio.h>

#include<conio.h>

void call_by_value(int x) {

               printf("Inside call_by_value x = %d before adding 10.\n", x);

               x += 10;

               printf("Inside call_by_value x = %d after adding 10.\n", x);

} 

void main() {

               int a=10;

               clrscr();

               printf("a = %d before function call_by_value.\n", a);

               call_by_value(a);

               printf("a = %d after function call_by_value.\n", a);

               getch();

} 

The output of this call by value code example will look like this:

a = 10 before function call_by_value.

Inside call_by_value x = 10 before adding 10.

Inside call_by_value x = 20 after adding 10.

a = 10 after function call_by_value. 

Ok, let’s take a look at what is happening in this call-by-value source code example. In the main() we create a integer that has the value of 10. We print some information at every stage, beginning by printing our variable a. Then function call_by_value is called and we input the variable a. This variable (a) is then copied to the function variable x. In the function we add 10 to x (and also call some print statements). Then when the next statement is called in main() the value of variable a is printed. We can see that the value of variable a isn’t changed by the call of the function call_by_value().

Call by Reference

If data is passed by reference, a pointer to the data is copied instead of the actual variable as is done in a call by value. Because a pointer is copied, if the value at that pointers address is changed in the function, the value is also changed in main(). Let’s take a look at a code example:

#include <stdio.h>

#include<conio.h>

void call_by_reference(int *y) {

               printf("Inside call_by_reference y = %d before adding 10.\n", *y);

               (*y) += 10;

               printf("Inside call_by_reference y = %d after adding 10.\n", *y);

}

void main() {

               int b=10;

               clrscr();

               printf("b = %d before function call_by_reference.\n", b);

               call_by_reference(&b);

               printf("b = %d after function call_by_reference.\n", b);

               getch();

} 

The output of this call by reference source code example will look like this:

b = 10 before function call_by_reference.

Inside call_by_reference y = 10 before adding 10.

Inside call_by_reference y = 20 after adding 10.

b = 20 after function call_by_reference. 

Let’s explain what is happening in this source code example. We start with an integer b that has the value 10. The function call_by_reference() is called and the address of the variable b is passed to this function. Inside the function there is some before and after print statement done and there is 10 added to the value at the memory pointed by y. Therefore at the end of the function the value is 20. Then in main() we again print the variable b and as you can see the value is changed (as expected) to 20.