以前，当我们将参数传递给函数时，我们一般使用普通变量，这称为pass-by-value方法。但是因为传递给函数的变量有可以出现超出了范围的问题，这样我们实际上无法修改参数的值。
引用传递
引用传递是指通过引用将参数传递给函数。调用时，该函数可以通过使用传入的引用来修改参数的值。
这使我们能够：
- 修改函数参数的值。
- 出于性能原因，避免复制变量/对象。
以下代码显示了传递引用的示例。调用函数时，引用参数用实际参数初始化：
#include <iostream>
using namespace std;
void swap(int &i,int &j){
int temp = i;
i = j;
j = temp;
}
int main(){
int a = 100;
int b = 200;
swap(a,b);
cout << a << endl;
cout << b << endl;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
- 14.
- 15.
- 16.
- 17.
- 18.
- 19.
请注意，int &i和int &j是函数的参数swap()。
当swap()被调用时，变量a和的值b将被修改，因为它们是通过引用传递的。输出将是：
200
100
- 1.
- 2.
下面有一个函数被调用triple()，有一个main()我们调用了triple()两次。大家认为这段代码会输出什么?
#include <iostream>
int triple(int i) {
i = i * 3;
return i;
}
int main() {
int num = 1;
std::cout << triple(num) << "\n";
std::cout << triple(num) << "\n";
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
函数Triple()的参数是int i，所以它在这里是通过值传递的;传入的参数num不会被修改。
因此输出为
3
3
- 1.
- 2.
将参数从 更改int i为int &i。现在正在做引用传递而不是值传递。你认为这现在会输出什么?
#include <iostream>
int triple(int &i) {
i = i * 3;
return i;
}
int main() {
int num = 1;
std::cout << triple(num) << "\n";
std::cout << triple(num) << "\n";
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
在第一次调用Triple()之后，num从1修改为3。因此，当第二次调用Triple()时，输出为9。
因此输出为
3
9
- 1.
- 2.
使用 Const 传递
const关键字告诉编译器，这样的变量不会改变的。
比如：double const pi = 3.14;。如果我们尝试更改pi，编译器将抛出错误。
有时，我们const在函数中使用参数;这是当我们知道我们想要编写一个函数，其中参数不会在函数内部更改的事实时。下面是一个例子：
int triple(int const i) {
return i * 3;
}
- 1.
- 2.
- 3.
- 4.
- 5.
在这个例子中，我们没有修改i. 如果在函数内部triple()，i更改了 的值，则会出现编译器错误。
因此，为了节省不修改参数值的函数的计算成本，我们实际上可以更进一步并使用const引用：
int triple(int const &i) {
return i * 3;
}
- 1.
- 2.
- 3.
const 确保参数不会改变。但是，通过&i引用参数，可以节省制作参数的计算成本。
下面有一个函数被调用，square()并且有一个main()，我们调用square()两次。
#include <iostream>
using namespace std;
int triple(int const &i) {
return i * 3;
}
int main(){
int a = 100;
cout << triple(a) << endl;
cout << triple(a) << endl;
}
- 1.
- 2.
- 3.
- 4.
- 5.
- 6.
- 7.
- 8.
- 9.
- 10.
- 11.
- 12.
- 13.
因此输出为
300
300
- 1.
- 2.
由于我们没有修改函数中的参数，再次运行代码，输出应该是一样的
