在 C++ 中可以定义“引用”。定义方式如下：

类型名 &引用名 = 同类型的某变量名;

此种写法就定义了一个某种类型的引用，并将其初始化为引用某个同类型的变量。“引用名”的命名规则和普通变量相同。例如：

int n;

int & r = n;

r 就是一个引用，也可以说 r 的类型是 int &。第二条语句使得 r 引用了变量 n，也可以说 r 成为了 n 的引用。

某个变量的引用和这个变量是一回事，相当于该变量的一个别名。

注意：定义引用时一定要将其初始化，否则编译无法通过。通常会用某个变量去初始化引用，初始化后，它就一直引用该变量，不会再引用别的变量。

也可以用一个引用去初始化另一个引用，这样两个引用就引用同一个变量。不能用常量初始化引用，也不能用表达式初始化引用(除非该表达式的返回值是某个变量的引用)。

总之，引用只能引用变量。

类型为 T& 的引用和类型为 T 的变量是完全兼容的，可以互相赋值。

引用的示例程序如下：

#include

using namespace std;

int main()

{

int n = 4;

int & r = n; //r引用了n，从此r和n是一回事

r = 4; //修改r就是修改n

cout << r << endl; //输出4

cout << n << endl; //输出4

n = 5; //修改n就是修改r

cout << r << endl; //输出 5

int & r2 = r; //r2和r引用同一个变量,就是n

cout << r2 << endl; //输出 5

return 0;

}

引用作为函数的返回值

函数的返回值可以是引用。例如下面的程序：

#include

using namespace std;

int n = 4;

int & SetValue()

{

return n; //返回对n的引用

}

int main()

{

SetValue() = 40; //返回值是引用的函数调用表达式，可以作为左值使用

cout << n << endl; //输出40

int & r = SetValue();

cout << r << endl; //输出40

return 0;

}

SetValue 函数的返回值是一个引用，是 int & 类型的。因此第 6 行使得其返回值成为变量 n 的引用。

第 10 行，SetValue 函数返回对 n 的引用，因此对 SetValue 函数的返回值进行赋值，就是对 n 进行赋值，结果就是使得 n 的值变为 40。

第 12 行，表达式 SetValue 函数的返回值是 n 的引用，因此可以用来初始化 r，其结果就 是 r 也成为 n 的引用。

引用作为函数的返回值，其用途会在后面的“运算符重载”和“标准模板库”章节中介绍。

参数传值

在 C++ 中，函数参数的传递有两种方式：传值和传引用。在函数的形参不是引用的情况下，参数传递方式是传值的。传引用的方式要求函数的形参是引用。

“传值”是指，函数的形参是实参的一个拷贝，在函数执行的过程中，形参的改变不会影响实参。例如下面的程序：

#include

using namespace std;

void Swap(int a, int b)

{

int tmp;

//以下三行将a、b值互换

tmp = a;

a = b;

b = tmp;

cout << "In Swap: a = " << a << " b = " << b << endl;

}

int main()

{

int a = 4, b = 5;

Swap(a, b);

cout << "After swaping: a = " << a << " b = " << b << endl;

return 0;

}

在上面的程序中，Swap 函数的返回值类型是 void，因此函数体内可以不写 return 语句。 在不写 return 语句的情况下，函数执行到末尾的}才返回。

上面程序的输出结果是：

In Swap: a = 5 b = 4

After swaping: a = 4 b = 5

输出结果说明，在 Swap 函数内部，形参 a、b 的值确实发生了互换，但是在 main 函数中， a、b 还是维持原来的值。也就是说，形参的改变不会影响实参。这是因为，形参和实参存放在不同的内存空间中。

一个程序在运行时，其所占用的内存空间有一部分被称作“栈”，当一个函数被调用时，在“栈”中就会分配出一块新的存储空间，用来存放形参和函数中定义的变量(也称为局部变量，如上面程序中的 tmp)。实参的值会被复制到栈中存放对应形参的地方，因此形参的值才等于实参。函数执行过程中对形参的修改，相当于只是修改了实参的一个拷贝，因此不会影响实参。

参数传引用

如果函数的形参是引用，那么参数的传递方式就是传引用的。在传引用方式下，形参是对应的实参的引用。也就是说，形参和对应的实参是一回事，形参的改变会影响实参。

有了引用的概念，交换两个变量的 Swap 函数可以如下编写：

#include

using namespace std;

void Swap(int & a, int & b)

{ //交换a、b的值

int tmp;

tmp = a; a = b; b = tmp;

}

int main()

{

int n1 = 100, n2 = 50;

Swap(n1, n2); //n1、n2 的值被交换

cout << n1 << " " << n2 << endl; //输出 50 100

}

第 11 行，进入 Swap 函数后，a 引用了 n1，b 引用了 n2，a、b 值的改变会导致 n1、n2 值的改变。因此本行会使 n1 和 n2 的值交换。

常引用

定义引用时，可以在前面加 const 关键字，则该引用就成为“常引用”。如：

int n;

const int & r = n;

上面的语句定义了常引用 r，其类型是 const int &。

常引用和普通引用的区别在于：不能通过常引用去修改其引用的内容。注意，不是常引用所引用的内容不能被修改，只是不能通过常引用去修改而已，但可以用别的办法修改。例如下面的程序片段：

int n = 100;

const int & r = n;

r = 200; //编译出错，不能通过常引用修改其引用的内容

n = 300; //没问题，n的值变为300

注意，const T& 和 T& 是不同的类型。T& 类型的引用或 T 类型的变量可以用来初始化 const T & 类型的引用，const T 类型的常变量和 const T & 类型的引用则不能用来初始化 T & 类型的引用，除非进行强制类型转换。例如下面的程序：

void Func(char & r) { }

void Func2(const char & r) { }

int main()

{

const char cc = 'a';

char c;

const char & rcl = cc;

const char & rc2 = c; //char变量可以用来初始化 const char & 的引用

char & r = cc; //编译出错，const char 类型的常变量不能用来初始化 char & 类型的引用

char & r2 = (char &)cc; //没问题，强制类型转换

Func(rcl); //编译出错，参数类型不匹配

Func2(rcl); //没问题，参数类型匹配

return 0;

}