Skip to main content

Difference between call by value and call by reference

Difference between pass by value and pass by reference

First Difference:
Call by value:  Value of the variable is passed as argument
Call by reference:  Address of the variable is passed as argument


  /* call by value vs call by reference */
  #include <stdio.h>

  void callByVal(int num) {
        num = 100;
        return;
  }

  void callByRef(int *num) {
        *num = 200;
        return;
  }

  int main() {
        int num = 10;
        printf("Call by value:\n");
        printf("Value of num before function call: %d\n", num);

        /* passing the value of the variable as argument */
        callByVal(num);

        printf("Value of num after function call: %d\n", num);
        printf("Call by reference:\n");
        printf("Value of num before function call: %d\n", num);

        /* passing address of the variable as argument */
        callByRef(&num);

        printf("Value of num after function call: %d\n", num);
        return 0;
  }



  Output:
  jp@jp-VirtualBox:~/$ ./a.out
  Call by value:
  Value of num before function call: 10
  Value of num after function call: 10
  Call by reference:
  Value of num before function call: 10
  Value of num after function call: 200



Second Difference:
Call by value: Any change to the value of the argument in called function is not carried out to the calling function.
Call by reference:  Any change to the value of the argument in called function is carried out to the calling function.


  /* pass by value vs pass by reference */
  #include <stdio.h>

  void callByVal(int val) {
        /* trying to change the value of the argument */
        val = val + 10;
        return;
  }

  void callByRef(int *val) {
        /* changing the value of the argument */
        *val = *val + 10;
        return;
  }

  int main() {
        int val = 10;
        printf("Call by value:\n");
        printf("Value of val before function call: %d\n", val);

        /* passing the value of the valiable as argument */
        callByVal(val);

        /* call by value - value of val is not changed */
        printf("Value of val after function call: %d\n", val);

        printf("Call by reference:\n");
        printf("Value of val before function call: %d\n", val);

        /* passing address of the valiable as argument */
        callByRef(&val);

        /* call by reference - value of val is changed */
        printf("Value of val after function call: %d\n", val);
        return 0;
  }



  Output:
  jp@jp-VirtualBox:~/$ ./a.out
  Call by value:
  Value of val before function call: 10
  Value of val after function call: 10
  Call by reference:
  Value of val before function call: 10
  Value of val after function call: 20


Third Difference:
Call by value: Memory occupied by actual and formal arguments are different.
Call by reference: Memory occupied by actual and formal arguments are same.


  /* call by value vs call by reference */
  #include <stdio.h>

  void callByVal(int val) {
        /* memory location of formal argument */
        printf("Address inside called function:\n");
        printf("Address of val: 0x%x\n", (int)&val);
        return;
  }

  void callByRef(int *val) {
        int tmp;
        /* memory location of formal argument */
        printf("Address inside called function:\n");
        printf("Pointer value of val: 0x%x\n", (int)val);
        return;
  }

  int main() {
        int val = 10;

        printf("\nCall by Value:\n");
        /* memory location of actual argument */
        printf("Address of the variables inside calling function:\n");
        printf("Address of val: 0x%x\n", (int)&val);
        callByVal(val);

        printf("\nCall by reference:\n");
        /* memory location of actual argument */
        printf("Address of the variables inside calling function:\n");
        printf("Address of val: 0x%x\n", (int)&val);
        callByRef(&val);

        return 0;

  }



  Output:
  jp@jp-VirtualBox:~/$ ./a.out
  Call by Value:
  Address of the variables inside calling function:
  Address of val: 0xbfed0e0c
  Address inside called function:
  Address of val: 0xbfed0df0

  Call by reference:
  Address of the variables inside calling function:
  Address of val: 0xbfed0e0c
  Address inside called function:
  Pointer value of val: 0xbfed0e0c


Labels:

Comments

Post a Comment

Popular posts from this blog

Array of pointer to structure

Array of pointer to structure is nothing but an array whose elements are pointers to structure How to declare array of pointer to structure? Below is an example declaration for array of pointer to structure. struct student *arr[10]; Here, arr is an array 10 of pointer to structure student. Dynamic memory allocation: Below is the procedure to perform dynamic memory allocation for the structure pointers in an array. struct student { int age; char name[32]; }; fun() { int i = 0; struct student *arr[10]; for (i = 0; i < 10; i++) { /* dynamic memory allocation for 5 structure objects */ arr[i] = (struct student *)malloc(sizeof(struct student) * 5); } } Write a c program to pass an array of structure pointers to another function   #include <stdio.h>   #include <stdlib.h>   #include <string.h>   struct student {         int age, rollno;         char name[32];   };   /* printing details of stude...
Post a Comment
Read more

Nested function in C

What is nested function? If a function is defined inside another function, then it is called as nested function.  Nested function example in C: Consider the following example, int add(int a, int b) {        void print(int res) {          printf("Result is %d, res);       }       print(a+b);       return 0; } Here, print() is a nested function.  Because, it is defined inside another function named add() . Example C program using nested functions: #include <stdio.h> void add(int a, int b) { void print(int res) { // nested function printf("Result is %d\n", res); return; } print(a + b); // passing sum of a and b as parameter return; } int main() { add(10, 20); return 0; }   Output:   jp@jp-VirtualBox:~/$ ./a.out   Result is 30 Previous Next
Post a Comment
Read more

Difference between asterisk and ampersand operators in c

Address Operator (& - Ampersand): Returns address of the given variable.  Consider the following example, int *ptr, var = 10; ptr = &var; ptr = &var sets the address of the variable var to pointer ptr.  & is also called as reference operator. Let us try to understand the purpose of reference operator using the following example program.   #include <stdio.h>   int main() {         int var = 10, *ptr;         /* assigning address of variable var to pointer ptr */         ptr = &var;         /* printing the address of the variable var */         printf("Address of var is 0x%x\n", &var);         /* printing the value of pointer ptr */         printf("Value of ptr is 0x%x\n", ptr);         return 0;   }   Output:   jp@jp-VirtualBox:~/$ ./a.out   Address of var is 0x...
Post a Comment
Read more