What are the differences between call by value and call by reference in c plus plus?

Answer 1

Pass By Reference :

In Pass by reference address of the variable is passed to a function. Whatever changes made to the formal parameter will affect to the actual parameters

- Same memory location is used for both variables.(Formal and Actual)-

- it is useful when you required to return more then 1 values

Pass By Value:

- In this method value of the variable is passed. Changes made to formal will not affect the actual parameters.

- Different memory locations will be created for both variables.

- Here there will be temporary variable created in the function stack which does not affect the original variable.

Answer 2

When you pass a parameter by value, you are creating a copy of the original variable and the receiving (method/function) cannot change the original value. When you pass by reference you are passing a pointer to the original object and therefore any changes are made to the original value.

Answer 3

Pass by value calls a function or returns a value based on the number or "value". Maybe you're calling a function with the value of 5, you would just call the function passing the 5. The function can't change the 5, it's always a 5. Pass by reference calls a function and passes a pointer to a memory location that contains the value. You might call the function pointing to a location that contains the number of people who live in your home. That location has been populated with a value, so the function can look at that location and determine that yes, there are 5 members in your family. But the function may be responsible for updating the number of people in your family and you just had a baby, so the function would update the value that is stored at the location. Pass by reference just gives a "pointer" to the memory location. In reality, when a string value is used in any "C" application, it passed by reference.

Answer 4

In .NET:

Both are passed by pointer. However, call by value the actual value (caller value) passed will not change. Call by reference the actual value (caller value) passed will change.

Answer 5

Pass by value and pass by reference refers to the way in which an object is passed into a function, as determined by the function itself. The following examples demonstrate the difference between the two types of function.

void byVal(int i);

void bRef(int& i);

Note that the only difference is that the parameter in byRef() includes the reference operator (&). To understand how these differ, let's define these functions with trace code to examine the properties of the variables they actually work with.

void byVal(int x)

{

cout<

cout<<"x at memory address 0x"<

cout<<" with value "<

}

void byRef(int& x)

{

cout<

cout<<"x at memory address 0x"<

cout<<" with value "<

}

int main()

{

int y=5;

cout<

cout<<"y at memory address 0x"<

cout<<" with value "<

byVal(y);

byRef(y);

return(0);

}

Output:

main(): y at memory address 0x0020FD04 with value 5

byVal(x): x at memory address 0x0020FC18 with value 5

byRef(x): x at memory address 0x0020FD04 with value 5

Note that while the memory addresses may vary each time you run this program, the memory address of y in main() is always the same as the memory address of x in byRef(), while the memory address of x in byVal() is always different. You might ask how it is possible for two variables to reside at the exact the same memory address, but the answer is that there is only one variable, y, and the x in byRef() simply refers to this variable. That is, a reference is simply an alias for a variable, an alternate name.

Passing by reference is the preferred method of passing complex objects to functions. To understand why, let's look at a more complex example where the variable is an user-defined object. We'll also include some trace code within the object's constructors so we can see exactly what goes on Behind the Scenes.

#include

#include

using namespace std;

class obj

{

public:

obj(int data):m_data(data) { cout<

cout<<" with value "<

return( os );

}

void byVal(obj x)

{

cout<

cout<<"x"<

}

void byRef(obj& x)

{

cout<

cout<<"x"<

}

int main()

{

obj y=5;

cout<

byVal(y);

byRef(y);

return(0);

}

Output:

1. obj(): m_data=5
2. main(): y at memory address 0x001FF98C with value 5
3. obj(obj): m_data=5
4. byVal(x): x at memory address 0x001FF894 with value 5
5. byRef(x): x at memory address 0x001FF98C with value 5

Note that line numbers have been included in the output for reference.

Line 1 of the output corresponds with the first line in main(), where y is constructed and initialised with the value 5 (the output line was emitted by the default constructor).

Line 2 corresponds with the second line in main().

Line 3 is a trace from the object's copy constructor. The copy constructor was invoked automatically the moment we called byVal, which then assigned that copy to x.

Line 4 is a trace from byVal(), showing that x resides at a different address to that of y.

Line 5 is the trace from byRef(), showing that x is the same instance as y.

You will note that line 3 demonstrates why passing objects by value is so inefficient. Imagine if y were a highly complex object, such as a polymorphic object containing multiple embedded objects and derived from multiple base classes. Every time you pass that object to a function by value you create a copy of that object, and every object encapsulated by the class, including its base classes and its derivatives, also has to be copied as part of the construction process. This is detrimental to both performance and memory consumption.

While it may occasionally be necessary to pass a copy of an object into a function in order to prevent the function from changing the original object, this can easily be catered for by providing two overloads for every function: one that accepts a reference, and another that accepts a value. The by value overload then simply passes its copy to the by reference overload.

But when a function does not need to alter any of the object's immutable members, a single by reference function is all that is required. Moreover, you can re-enforce the constant nature of the object by declaring the parameter as a constant reference:

void byRef(const& obj);

The use of the const keyword has two purpose: primarily to alert consumers to the fact the object's immutable members will not be altered in any way by the function (only constant member functions will be accessible to the function), but also to ensure that you yourself do not inadvertently alter the object should you later decide to modify the implementation of the function. In other words you enlist the compiler to prevent you from doing things you shouldn't be doing, thus ensuring your code remains robust.

You will note that passing by reference is effectively the same as passing a pointer to your object. However, you should always use references rather than pointers when passing objects to functions, unless the object is an optional parameter. In this case, you can default the pointer parameter to NULL which can't be done with a reference (a NULL reference completely invalidates your program). In other words, a reference must always refer to an existing object, whereas a pointer can refer to NULL. Thus if an object must exist for a function to work, use pass a reference, otherwise use pass by pointer.

Note also that pointers are always passed by value. In order to treat a pointer by reference, you must pass an indirect pointer instead (such as a pointer to a pointer). This then allows the function to not only alter the object being pointed at (assuming the pointer type is not constant), but also to change which object it points at (assuming the pointer itself is not constant).

Answer 6

first you need to understand the formal and actual parameter.An actual parameter is the parameter passed to a function while calling it, a formal parameter is a parameter to which the values passed from the calling function is assigned.

When a function is called and a copy of values of actual parameters is passed to the called function, it's called as call by value.

When the address of actual parameter is passed to the called function, it's called as call by reference.

e.g.

if int a,b; is a declaration in a calling function and a function call to a function having prototype, int add(int, int) is made i.e.

add(a,b) ;

then it's call by value.

And if function call to a function having prototype, voidadd(int* , int* ) is made i.e.

add(&a,&b) ;

then it's call by reference.

Answer:

There is only call-by-value in C; you can emulate call-by-reference using pointers.

Answer 7

Pass by value copies the value whereas pass by reference passes the actual value. As a result, pass by reference is quicker. If a function does not need to alter the value being passed, then there's little point in passing it by value. A constant reference is a far better option. If the function does alter the value, and the changes are expected, a non-constant reference is the ideal choice. If changes are not expected, then either pass by value, or copy the value and then pass the copy by reference.

Pointers are always passed by value (only the pointer is copied, not the object being pointed at), but they act like references. However, pointers should only be passed if there's ever a possibility of passing a pointer to NULL. If an object is guaranteed to exist, passing by reference is the method of choice.

Passing by constant value is a pointless endeavour since the value is copied, and the copy will fall from scope when the function returns, and therefore has no effect on the actual parameter passed by the caller. However, if the value must remain constant within the function, declaring the formal parameter as a constant is no bad thing.

Answer 8

When you pass by value you pass a copy of the value. When you pass by reference, you pass the address of the value.

void foo(int x){x*=2;} // pass by value

void bar(int &x){x*=2} // pass by reference

int main()

{

int y=1;

foo(y);

bar(y);

return( 0 );

}

In the above example, calling foo(y) passes the value of y (1) which is then assigned to x in the function. x and y are separate variables so although foo() changes the value of x, this has no effect on y which is still 1 when the function returns.

Calling bar(y), on the other hand, passes the address of y and assigns that address to the reference x. Both x and y refer to the same memory so when bar() changes the value of x it changes the value of y, thus y will be 2 when the function returns.

Note that the only difference with pass by reference is that the parameter x has an ampersand to denote that it is a reference to the argument (addressof) rather than a local copy of the argument's value.

Pass by reference is the preferred method of passing all complex objects to functions as there is no need to copy the object. Failure to do so will result in an often unnecessary overhead in calling the object's copy constructor. Where the function does not need to alter the object, the reference should be declared const. If it is non-const, the caller can fully expect any changes to be reflected in the original object. The only time a function should ever accept complex objects by value is when it must change the object but must not change the object that was passed. Passing by value ensures the function only works on a copy of the object.

Note that pass by reference is not unlike pass by pointer. The only difference is that pointers must always be passed by value. To mimic passing a pointer by reference, you must pass a pointer to pointer instead.