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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
void foo(int y) { using namespace std; cout << "y = " << y << endl; } int main() { foo(5); // first call int x = 6; foo(x); // second call foo(x+1); // third call return 0; } |
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:
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
void foo(int y) { using namespace std; cout << "y = " << y << endl; y = 6; cout << "y = " << y << endl; } // y is destroyed here int main() { using namespace std; int x = 5; cout << "x = " << x << endl; foo(x); cout << "x = " << x << endl; return 0; } |
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.
 7.3 -- Passing arguments by reference
|
 Index
|
 7.1 -- Function parameters and arguments
|
Great tutorial,i think i will make a good programmer out of this.
Write a function which will take a string and returns the word count. Each word is separated by a single space.
[nvm]
edit: nevermind. I can't read.
Your fist example prints "y = ", not "y is "
and you need to put use the std namespace in your main
[ Fixed! Thanks! -Alex ]
can enum be passed as parameter through this method(pass by value)?
Yep, and they almost always are.
Shouldn't lines 4 and 8 read "y= "
and then y, not x ?
[ Yep. Thanks for catching that. In the future, if you want to post code, put your code between PRE html tags. Otherwise wordpress/HTML eats the formatting. -Alex ]