Passing arguments by value

Pass by value
By default, arguments in C++ are passed by value. When arguments are passed by value, a copy of the argument is passed to the function.
Consider the following snippet:

01	void foo(int y)

02

{

03	using namespace std;

04	cout << "y = " << y << endl;

05

}

06

07	int main()

08

{

09	foo(5); // first call

10

11	int x = 6;

12	foo(x); // second call

13	foo(x+1); // third call

14

15

return 0;

16

}

In the first call to foo(), the argument is the literal 5. When foo() is called, variable y is created, and the value of 5 is copied into y. Variable y is then destroyed when foo() ends.
In the second call to foo(), the argument is the variable x. x is evaluated to produce the value 6. When foo() is called for the second time, variable y is created again, and the value of 6 is copied into y. Variable y is then destroyed when foo() ends.
In the third call to foo(), the argument is the expression x+1. x+1 is evaluated to produce the value 7, which is passed to variable y. Variable y is once again destroyed when foo() ends.
Thus, this program prints:

y = 5
y = 6
y = 7

Because a copy of the argument is passed to the function, the original argument can not be modified by the function. This is shown in the following example:

01	void foo(int y)

02

{

03	using namespace std;

04	cout << "y = " << y << endl;

05

06

y = 6;

07

08	cout << "y = " << y << endl;

09	} // y is destroyed here

10

11	int main()

12

{

13	using namespace std;

14	int x = 5;

15	cout << "x = " << x << endl;

16

17

foo(x);

18

19	cout << "x = " << x << endl;

20

return 0;

21

}

This snippet outputs:

x = 5
y = 5
y = 6
x = 5

At first, x is 5. When foo() is called, the value of x (5) is passed to variable y inside foo(). y is assigned the value of 6, and then destroyed. The value of x is unchanged, even though y was changed.
Advantages of passing by value:

• Arguments passed by value can be variables (eg. x), literals (eg. 6), or expressions (eg. x+1).
• Arguments are never changed by the function being called, which prevents side effects.

Disadvantages of passing by value:

• Copying large structs or classes can take a lot of time to copy, and this can cause a performance penalty, especially if the function is called many times.

In most cases, pass by value is the best way to pass arguments to functions — it is flexible and safe.