When normal function call takes place, then the value of the actual arguments are copied to the formal arguments of the function. So, any changes to the formal arguments, within the function body does not affect the actual arguments.

let's take an example.

//defination of the function increment

void increment(int var){

  var++;

} 

//function call

int x = 10;

increment(x);

In above example, when increment function is called with parameter x passed, then the value of x is copied to the variable var. So, the increment in the var variable only takes place for the local variable of the var variable of the increment() function,  and the increment does not seem in x. But there may arise some situation where we need the effect on actual arguments. Lets consider the following question.

Q. Write a C++ program to swap the value of the two variable in main program using function.

#include
using namespace std;

// declaration and defination of the function to swap
void swap(int &xv, int &yv){
	// swapping using third variable
	int temp = xv;
	xv = yv;
	yv = temp;
}

int main(){
	int x = 10, y = 20;
	cout<<"Before swap:"<<"x = "<<x<<" and y = "<<y<<endl;
	swap(x,y); //swap function call
	cout<<"After swap:"<<"x = "<<x<<" and y = "<<y<<endl;
	return 0;
}

sample run:

Before swap:x = 10 and y = 20
After swap:x = 20 and y = 10

Constant Reference arguments:

Let's see the scenario of above, the function with pass by reference, changes the variable in the actual arguments. That means any changes on the varibles in the function reflects on the actual arguments. What if we do not want to change the actual parameter values. Or, if mistakenly the actual parameter changes then, there will be blunder on the program. You may answer easily why not to use pass by value ??

And the answer is No, i mean not that good to use pass by value. and i will explain why? During the function call, if the object or array is to be passed in large size, then it will cause the large sized variables to be created, and obviously the more memory is required during the function call. But in case of reference arguments just the reference is passed, no variables are created.

To prevent the alteration of the actual arguments by the function, the constant reference arguments comes to play role. And if we try to change the constant reference arguments then error will occur, and ensures the prevention of the modification of the actual arguments.

Syntax:

return_type function_name( const data_type &ref_variable){

  //body or statements of the function

}