引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量。
引用和指针
引用很容易与指针混淆，它们之间有三个主要的不同：
- 不存在空引用。引用必须连接到一块合法的内存。
- 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
- 引用必须在创建时被初始化。指针可以在任何时间被初始化。
创建引用
假设变量名称是变量附属在内存位置中的标签，则可以把引用当成变量附属在内存位置中的第二个标签。因此，可以通过原始变量名称或引用来访问变量的内容。例如：
int i = 17;
int & r = i;
double d = 30.0;
double & s = d;
注意：语句中的&运算符不是地址运算符，而是将 i 的类型声明为int &，即指向int变量的引用。
在声明中，& 读作引用。因此，第一个声明可以读作 "r 是一个初始化为 i 的整型引用"，第二个声明可以读作 "s 是一个初始化为 d 的 double 型引用"。下面的实例使用了 int 和 double 引用：
#include <iostream>
using namespace std;
int main()
{
/* 声明简单的变量 */
int i = 5;
double j = 10.0;
/* 声明引用变量 */
int & m = i;
double & n = j;
cout << "Value of i : " << i << endl;
cout << "Value of i reference : " << m << endl;
cout << "Value of j : " << j << endl;
cout << "Value of j reference : " << n << endl;
return 0;
}
编译和执行上面的代码：
Value of i : 5
Value of i reference : 5
Value of j : 10
Value of j reference : 10
引用通常用于函数参数列表和函数返回值。
使用引用来实现引用调用函数:
#include <iostream>
using namespace std;
void swap(int& x, int& y); // 函数声明
int main()
{
/* 局部变量声明 */
int a = 100;
int b = 200;
cout << "交换前，a 的值：" << a << endl;
cout << "交换前，b 的值：" << b << endl;
swap(a, b); //调用函数来交换值
cout << "交换后，a 的值：" << a << endl;
cout << "交换后，b 的值：" << b << endl;
return 0;
}
void swap(int & x, int & y) // 函数定义
{
int temp;
temp = x; // 保存地址 x 的值
x = y; // 把 y 赋值给 x
y = temp; // 把 x 赋值给 y
return;
}
编译和执行上面的代码：
交换前，a 的值：100
交换前，b 的值：200
交换后，a 的值：200
交换后，b 的值：100
使用引用替代指针，会使 C++ 程序更容易阅读和维护。函数可以返回一个引用，方式与返回一个指针类似。
当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。例如，请看下面这个简单的程序：
#include <iostream>
using namespace std;
double vals[] = { 10.1, 12.6, 33.1, 24.1, 50.0 };
/* 返回第i个元素的引用，ref是一个引用变量，ref引用 vals[i] */
double& setValues(int i)
{
double& ref = vals[i];
return ref;
}
int main()
{
cout << "改变前的值" << endl;
for (int i = 0; i < 5; i++)
{
cout << "vals[" << i << "] = ";
cout << vals[i] << endl;
}
setValues(1) = 20.23; // 改变第 2 个元素
setValues(3) = 70.8; // 改变第 4 个元素
cout << "改变后的值" << endl;
for (int i = 0; i < 5; i++)
{
cout << "vals[" << i << "] = ";
cout << vals[i] << endl;
}
return 0;
}
编译和执行上面的代码：
改变前的值
vals[0] = 10.1
vals[1] = 12.6
vals[2] = 33.1
vals[3] = 24.1
vals[4] = 50
改变后的值
vals[0] = 10.1
vals[1] = 20.23
vals[2] = 33.1
vals[3] = 70.8
vals[4] = 50
注意：当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。
int& func()
{
int q; // 若return q; 在编译时发生错误，因为局部变量q超出了作用域
static int x; // 安全，x 在函数作用域外依然是有效的
return x;
}
引用作为返回值，必须遵守以下规则：
- 不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。
- 不能返回函数内部新分配的内存的引用。虽然不存在局部变量的被动销毁问题，可对于这种情况，会面临其它尴尬局面。例如，被函数返回的引用只是作为一 个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（函数内部新分配的内存）就无法释放，造成内存泄漏。
- 可以返回类成员的引用，但最好是const。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。
