What the difference between call by reference and call by value return in c plus plus?

Answer 1

In a pass by pointer (*, the original C standard), you're not passing the actual variable but rather its address in memory. This is required because in standard C, all function parameters are passed by value and therefore disappear when the function call is completed. In order to access and alter the original variable, you have to dereference the pointer using the address provided in the pointer argument, and this must be done each time the original variable is altered. Keeping this in mind requires vigilance to be sure you know which object referring: the variable or its memory address.

In a pass by reference (&, introduced in C++), you're telling the compiler that the variable being passed into a function has to be fundamentally linked to the original. The compiler takes care of the dirty work and lets you refer to the variable with simple assignment statements--no pointer handling required.

Answer 2

Consider the code that follows. In the main() function we declare an integer, num, and initialise it to the value 100. We then call three separate functions which accept numas an argument, first by value, then by reference, and finally by pointer. In each case we double the value of the parameter to show the effect it has upon numitself.

Note how the PassByValue function makes a copy of num. We know this because the parameter val has a completely different memory address to that of num. This means that anything we do to val will not affect num.

However PassByRef passes num directly because ref is a reference to num (they both refer to the same memory address). Thus anything we do to ref we actually do to num. Thus num is doubled when we double ref.

Finally, PassByPtr proves that pointers are just variables that are passed by value, because ptr has its own memory address allocated to it. The value stored in this memory address is the memory address of num. Dereferencing this memory address shows us the value of num. Thus doubling the dereferenced value of ptr doubles the value of num.

#include

void PassByVal( int val )

{

printf( "PassByVal(int val)\taddress of val: 0x%.8x, value of val: %d\n" , &val, val );

val *= 2;

}

void PassByRef( int & ref )

{

printf( "PassByRef(int & ref)\taddress of ref: 0x%.8x, value of ref: %d\n" , &ref, ref );

ref *= 2;

}

void PassByPtr( int * ptr )

{

printf( "PassByPtr(int * ptr)\taddress of ptr: 0x%.8x, value of ptr: 0x%.8x, dereferenced value of ptr: %d\n" , &ptr, ptr, *ptr );

*ptr *= 2;

}

int main()

{

int num = 100;

printf( "main()\t\t\taddress of num: 0x%.8x, value of num: %d\n" , &num, num, );

PassByVal( num );

printf( "main()\t\t\taddress of num: 0x%.8x, value of num: %d\n" , &num, num );

PassByRef( num );

printf( "main()\t\t\taddress of num: 0x%.8x, value of num: %d\n" , &num, num );

PassByPtr( &num );

printf( "main()\t\t\taddress of num: 0x%.8x, value of num: %d\n" , &num, num );

}

Answer 3

In call by value, you can only pass values stored in variables and catch them in other variables, actual variables are mostly unaffected (value of only one variable can be modified in one call). In call by reference, you pass address of variables, so actual variables are modified (multiple values can be modified in one call).

Answer 4

C++ only supports the call by value semantic. When we pass an object to a function, we do not pass the object we pass the object's value. To achieve this, the object must be copied. Thus the function operates upon a copy of the object, never the object itself.

Pass by reference applies when the object being passed is a memory address. The address is passed by value just like any other object, however when an address refers to an object, we are actually passing a reference to that object. Addresses can be passed by reference or by pointer (preferably constant reference or constant pointer). We use pointers when "no object" is a valid argument, otherwise we use references.

Copying objects can be expensive (depending on their size, in bytes), but copying an object's address has minimal cost and can be done in constant time. Thus we can pass objects of any size to functions much more efficiently by passing their addresses rather than their values.