Can anyone explain me difference between call by value and all by reference with examples?

Question

i am not understanding this difference

Answer 1

in pass by value when we use a variable as argument it's value is used that means a different variable with same value so even if you change anything to the variable it will not change.
int x=5
add(x){
x++;
return x;
}
now output is 6 but x is still 5.
in value by reference the address of variable is taken thus changes we make are changed
add(ref x){
x++;
return x;}
now output is also 6 and x is also 6
in pass by output we instead of taken value in we assign value to variable
add(out x){
x=y+1;
}
here code was written in c#.

Answer 2

To pass in by value means a copy of the value inside the variable is sent over. When the method ends, any changes made to that value are *not* reflected on the variable. Ex:
int num = 10;
doubleNum(num); //Sends over 10.
cout << num; //Equals 10.

void doubleNum(int inNum)
{
inNum *= 2; //Equals 20.
cout << inNum;
return;
}

To pass in by reference means the variable's memory address is sent over. A pointer is needed to receive it and use it correctly.
This pointer gives the method the ability to modify the variable itself, not just a copy of what it held. When it returns, any changes made *will remain*. Ex:
int num = 10;
doubleNum(&num); //Equals 10 going in.
//Passed in num's mem. address.
cout << num; //Equals 20 coming out.

void doubleNum(int *inNum)
{
inNum *= 2; //Equals 20
cout << inNum;
return;
}

Also, whole arrays and objects are always passed into methods by reference, as they are reference types.

Answer 3

In call by value,No pointers are used in call by reference approach.
The value of the variables are passed as arguments to the function in Pass By Value method.
A copy of the original variables are created in memory stack.
The actual and formal parameters are created on a different memory stack.

In call by reference,The pointers are used in call by reference approach.
The address of the variables are passed as arguments to the function in Pass By Reference method.
No copy of the variables are created on the memory stack.
The actual and formal parameters are created on the same memory stack.

Answer 4

Basically they are the ways to call a function
1st keep in mind that Variable has its address and its value. Operator & used to access the address of variable.
|-----| <----- A Memory location
| 20 |
|_____| <----- Variable_Name
0x6f77 <----- Address of location

Call by Value:
Pass a variable to a function
Copy the passed variable's Value
Change in this value by function doesnt effect on passed variable... bcz here two independent variable working

void foo(int y) { // y copy the passed
// variable's
// value i.e. y=20
cout<< ++y; // add 1 to y i.e. y=21
}
int main() {
int x=20;
foo(x); // pass variable x to
// function
cout<< x; // print x after fun call
return 0;
}
result:
x----->[20] y----->[21]
________________________________
Call by Reference:
Pass a reference/location/address of variable to a function.
Copy the address of passed variable
Change in this value by function effect on passed variable... bcz variable address is same.

void foo(int &y) { //copy the location of
//passed variable
cout<< ++y; // aad 1 to value of
// that location
}
int main() {
int x=20;
foo(x); // pass a variable x
cout<< x;
return 0;
}
result:
x-----> [21] <------y

Answer 5

In call by value the arguments are copied into an another variable, and all the operations in the function are done on the copy ( original variables are left untouched).
So, in call by value, the changes made to the variables in the function would not reflect back in the calling function.

example:
func(int a)
{ a =3;
//print a
}
main()
{ int x =1;
//print x
func(x);
//print x
}
here, the given code prints 1 3 1, as only tbe value of formal paramater is changed.

In call by reference an alliance is created for the arguement passed to the function. It's an another name given to the same memory block (just like your name and your pet name). So, all the changes made in the function body reflects back in the calling function.
In this case, the above code will print 1 3 3, as the value of actual paramater is changed.

Answer 6

The call by value method of passing arguments to a function COPIES the actual VALUE of an argument into the parameter of the function. In this case, changes made to the parameter inside the function have no effect on the argument.
It affects only the copy that is being used.

The call by reference method, means that the parameter will be the same as the actual-passed argument. Thus, any changes to the parameter will affect the argument, too.

You can check out a C++ code that I ve posted in my profile with an example of a function for swapping the values of two variables, by value and by reference.

Answer 7

dude in call by value the value of the variable is passed through function
like this
void main()
{
int a=10,b=5;
swap(a,b);
}
swap(into a,int b)
{
int tmp;
tmp=a;
a=b;
b=tmp
return 0;
}
observe that here the value of a and b is not swapped
now in call by reference we pass actual address of the variable and this result is stored in pointer
ex
int *p,a;
p=&a;
here p actually contain the address of a
so if send the address of variable in pointer than
you can change its value through its address
this is what we call call by reference .sorry for bad explanation .

Answer 8

In call by value the actual value is passed as an argument to the function.
example
a=10;
c=call(a)
here the value 10 will be passed to the function.

In call by reference the address of the value is passed as an argument to the function.
example
a=10 //assume a is in memory having address 1001
c=call(&a) // here the address of a will b passed as argument I.e. 1001

Answer 9

passing the variable as a parameter to other function is called call by value.
and passing an address where the value is. is called cal by reference.

in cal by value you can only pass a value.
by with call by reference you can pass an array. this Is the main purpose of cal by reference.. !!

Answer 10

call by value: generates the another copy of the variable and perform operation over that.
No impact on original variables

call by ref: As the name suggest, there is reference to the original variables that means whatever the operations are, they are going to make an impact on original values.

Answer 11

It is simple concept, if you understand very basics like
function parameter passing mechanism and what happens to call stack and
also variable-memory organization, in order to understand difference call by value & call by reference.
without basics, never even try understanding...

Answer 12

when you pass by value you are passing a copy of the variable, so any changes made to the value of that copy only effect the copy and do not change the original variable.

passing by reference is passing the actual reference (memory address) of the variable so any changes done on the variable, will be changing the original.

Answer 13

"Passing by reference means the called functions' parameter will be the same as the callers' passed argument (not the value, but the identity - the variable itself). Pass by value means the called functions' parameter will be a copy of the callers' passed argument."

Answer 14

yeap I can

Answer 15

Call by value

In call by value, original value can not be changed or modified. In call by value, when you passed value to the function it is locally stored by the function parameter in stack memory location. If you change the value of function parameter, it is changed for the current function only but it not change the value of variable inside the caller function such as main().

#include<iostream.h>
#include<conio.h>
void swap(int a, int b)
{ int temp; temp=a; a=b; b=temp; }
void main()
{
int a=100, b=200;
clrscr();
swap(a, b);
// passing value to function
cout<<"Value of a"<<a;
cout<<"Value of b"<<b;
getch();
}

Output

Value of a: 200 Value of b: 100

Call by reference

In call by reference, original value is changed or modified because we pass reference (address). Here, address of the value is passed in the function, so actual and formal arguments shares the same address space. Hence, any value changed inside the function, is reflected inside as well as outside the function.

Example

#include<iostream.h>
#include<conio.h>
void swap(int *a, int *b)
{ int temp; temp=*a; *a=*b; *b=temp; }
void main()
{
int a=100, b=200;
clrscr();
swap(&a, &b);
// passing value to function
cout<<"Value of a"<<a;
cout<<"Value of b"<<b;
getch();
}

Output

Value of a: 200 Value of b: 100

Answer 16

In call by value the variables are passed as parameters to the function directly. But in call by reference the pointers of respective variables are passed as formal paameters.

Answer 17

There is one other thing worth pointing out. If you pass anything other than a simple variable to a function then even if you say by value you will get it by reference. Compilers don't make copies of complex objects.

Answer 18

In call by value we send direct value that can be constant or variable but in call by reference we send reference of the value i.e. The address from where to get the value. Both have different advantages.

Answer 19

I also do not know the difference

Answer 20

as i know
I will explain in lay man language
calling by value I meant by
ex. someone call u by ur "name" //first name
calling by reference
ex. someone call u by ur "surname"