引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字。一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量

C++ 引用 vs 指针

引用很容易与指针混淆，它们之间有三个主要的不同：

  • 不存在空引用。引用必须连接到一块合法的内存。
  • 一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
  • 引用必须在创建时被初始化。指针可以在任何时间被初始化。

C++ 中创建引用

试想变量名称是变量附属在内存位置中的标签，您可以把引用当成是变量附属在内存位置中的第二个标签。因此，您可以通过原始变量名称或引用来访问变量的内容。例如：

  1. int i = 17;

我们可以为 i 声明引用变量，如下所示：

  1. int&  r = i;
  2. double& s = d;

在这些声明中，& 读作引用。因此，第一个声明可以读作 “r 是一个初始化为 i 的整型引用”，第二个声明可以读作 “s 是一个初始化为 d 的 double 型引用”。下面的实例使用了 int 和 double 引用：

  1. #include <iostream>
  3. using namespace std;
  5. int main ()
  6. {
  7.    // 声明简单的变量
  8.    int    i;
  9.    double d;
  10.    int   i1;
  12.    // 声明引用变量
  13.    int&    r = i;
  14.    double& s = d;
  16.    i = 5;
  17.    cout << "Value of i : " << i << endl;
  18.    cout << "Value of i reference : " << r  << endl;
  20.    d = 11.7;
  21.    cout << "Value of d : " << d << endl;
  22.    cout << "Value of d reference : " << s  << endl;
  24.    i = 66;
  25.    d = 666.66;
  26.    cout << "修改后的 i : " << i << endl;
  27.    cout << "修改后的 d : " << d  << endl;
  28.    cout << "修改后的 i reference : " << r << endl;
  29.    cout << "修改后的 d reference : : " << s  << endl;
  31.    r = 88;
  32.    s = 888.888;
  33.    cout << "修改后的 i : " << i << endl;
  34.    cout << "修改后的 d : " << d  << endl;
  35.    cout << "修改后的 i reference : " << r << endl;
  36.    cout << "修改后的 d reference : : " << s  << endl;
  37.    return 0;
  38. }
  40. /* 
  41. Value of i : 5
  42. Value of i reference : 5
  43. Value of d : 11.7
  44. Value of d reference : 11.7
  45. 修改后的 i : 66
  46. 修改后的 d : 666.66
  47. 修改后的 i reference : 66
  48. 修改后的 d reference : : 666.66
  49. 修改后的 i reference : 88
  50. 修改后的 d reference : : 888.888
  51. */

引用通常用于函数参数列表和函数返回值。下面列出了 C++ 程序员必须清楚的两个与 C++ 引用相关的重要概念：

概念 描述
把引用作为参数 C++ 支持把引用作为参数传给函数，这比传一般的参数更安全
把引用作为返回值 可以从 C++ 函数中返回引用，就像返回其他数据类型一样

把引用作为参数

我们已经讨论了如何使用指针来实现引用调用函数。下面的实例使用了引用来实现引用调用函数

  1. #include <iostream>
  2. using namespace std;
  4. // 函数声明
  5. void swap(int& x, int& y);
  7. int main ()
  8. {
  9.    // 局部变量声明
  10.    int a = 100;
  11.    int b = 200;
  13.    cout << "交换前，a 的值：" << a << endl;
  14.    cout << "交换前，b 的值：" << b << endl;
  15.    swap(a, b); // 调用函数来交换值
  16.    cout << "交换后，a 的值：" << a << endl;
  17.    cout << "交换后，b 的值：" << b << endl;
  18.    return 0;
  19. }
  21. // 函数定义
  22. void swap(int& x, int& y)
  23. {
  24.    int temp;
  25.    temp = x; // 保存地址 x 的值
  26.    x = y;    // 把 y 赋值给 x
  27.    y = temp; // 把 x 赋值给 y 
  28.    return;
  29. }
  31. /*
  32. 交换前，a 的值：100
  33. 交换前，b 的值：200
  34. 交换后，a 的值：200
  35. 交换后，b 的值：100
  36. */

把引用作为返回值

通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似。
当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边。例如，请看下面这个简单的程序：

  1. #include <iostream>
  2. using namespace std;
  5. double vals[] = {1.1, 2.2, 3.3};
  6. double& setValues(int i) {  
  7.    double& ref = vals[i];    
  8.    return ref;   // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]，最后再返回 shit。
  9. }
  11. int main ()
  12. {
  14.    cout << "改变前的值" << endl;
  15.    cout << "vals[0]: " << vals[0] <<endl;
  16.    cout << "&vals[0]: " << &vals[0] <<endl;
  17.    for ( int i = 0; i < 4; i++ )
  18.    {
  19.        cout << "vals[" << i << "] = "  << vals[i] << endl;;
  20.    }
  22.   cout << "setValues(0): " << setValues(0) <<endl;
  23.   cout << "&setValues(0): " << &setValues(0) <<endl;
  24.    setValues(0) = 11.11; // 改变第 1 个元素
  25.    setValues(1) = 22.22;  // 改变第 2 个元素
  26.    setValues(2) = 33.33;  // 改变第 2 个元素
  27.    setValues(3) = 44.44;  // 改变第 4 个元素
  29.    cout << "改变后的值" << endl;
  30.    for ( int i = 0; i < 4; i++ )
  31.    {
  32.        cout << "vals[" << i << "] = " << vals[i] << endl;;
  33.    }
  34.    return 0;
  35. }
  37. /* 
  38. 改变前的值
  39. vals[0]: 1.1
  40. &vals[0]: 0x102eb1100
  41. vals[0] = 1.1
  42. vals[1] = 2.2
  43. vals[2] = 3.3
  44. vals[3] = 0
  45. setValues(0): 1.1
  46. &setValues(0): 0x102eb1100
  47. 改变后的值
  48. vals[0] = 11.11
  49. vals[1] = 22.22
  50. vals[2] = 33.33
  51. vals[3] = 44.44
  52. */

当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用。

  1. int& func() {
  2.    int q;
  3.    //! return q; // ❌ 在编译时发生错误
  4.    static int x;
  5.    return x;     // ✅ 安全，x 在函数作用域外依然是有效的
  6. }