前言

  本笔记所涉及到的编程环境与 《C++ · 代码笔记1 · 从C到C++》 中的编程环境一致，具体可参考此笔记。

011引用初探_引用与普通变量

  相关代码：

#include <iostream>int main()
{int a = 99;                               // 定义整型变量a并初始化为99int &r = a;                               // 定义整型引用r并初始化为a的引用std::cout << a << ", " << r << std::endl; // 输出a的值和r的值，由于r是a的引用，所以它们的值相同std::cout << &a << std::endl;             // 输出a的地址std::cout << &r << std::endl;             // 输出r的地址，由于r是a的引用，所以它们的地址也相同return 0;
}

  运行结果：

012引用初探_引用作为函数参数

  相关代码：

#include <iostream>/*** 函数swap1：值传递方式交换两个整数* @param a 第一个整数* @param b 第二个整数* 注意：此函数不会改变实参的值，因为它是通过值传递的*/
void swap1(int a, int b)
{int temp = a; // 使用临时变量保存a的值a = b;        // 将a的值设置为bb = temp;     // 将b的值设置为a原始的值
}/*** 函数swap2：指针传递方式交换两个整数* @param p1 指向第一个整数的指针* @param p2 指向第二个整数的指针* 注意：此函数会改变实参的值，因为它是通过指针传递的*/
void swap2(int *p1, int *p2)
{int temp = *p1; // 使用临时变量保存p1指向的值*p1 = *p2;      // 将p1指向的值设置为p2指向的值*p2 = temp;     // 将p2指向的值设置为p1原始的值
}/*** 函数swap3：引用传递方式交换两个整数* @param r1 第一个整数的引用* @param r2 第二个整数的引用* 注意：此函数会改变实参的值，因为它是通过引用传递的*/
void swap3(int &r1, int &r2)
{int temp = r1; // 使用临时变量保存r1的值r1 = r2;       // 将r1的值设置为r2r2 = temp;     // 将r2的值设置为r1原始的值
}int main()
{int num1, num2;std::cout << "值传递，请输入两个整型数据: ";std::cin >> num1 >> num2;swap1(num1, num2);std::cout << num1 << " " << num2 << std::endl;std::cout << "指针传递，请输入两个整型数据: ";std::cin >> num1 >> num2;swap2(&num1, &num2);std::cout << num1 << " " << num2 << std::endl;std::cout << "引用传递，请输入两个整型数据: ";std::cin >> num1 >> num2;swap3(num1, num2);std::cout << num1 << " " << num2 << std::endl;return 0;
}

  运行结果：

013引用初探_引用作为函数返回值

  相关代码：

#include <iostream>
using namespace std;/*** 函数func：通过引用修改参数并返回引用* @param r 输入的整型引用参数* @return 返回修改后的整型引用* 注意：此函数通过引用修改传入的参数，并且返回修改后的引用*/
int &func(int &r)
{r += 10;  // 将传入的引用参数的值增加10return r; // 返回修改后的引用参数
}int main()
{int num1 = 10;         // 定义并初始化整型变量num1为10int num2 = func(num1); // 调用func函数，传入num1的引用，并将返回的引用赋值给num2// 此时num1和num2的值都为20，因为它们引用的是同一个变量cout << num1 << " " << num2 << endl; // 输出num1和num2的值return 0;
}

  运行结果：

014引用初探_引用返回局部函数造成的错误

  相关代码：

#include <iostream>
using namespace std;/*** 函数plus10：计算输入整型引用参数加10的结果，并返回一个新的整型引用* @param r 输入的整型引用参数* @return 返回一个新的整型引用，其值为输入参数加10* 注意：此函数返回的是一个局部变量的引用，这是一个危险的操作，* 因为局部变量在函数调用结束后会被销毁，返回其引用可能会导致未定义行为。*/
int &plus10(int &r)
{int m = r + 10; // 创建一个局部变量m，其值为输入参数r加10return m;       // 返回局部变量m的引用
}int main()
{int num1 = 10;           // 定义并初始化整型变量num1为10int num2 = plus10(num1); // 调用plus10函数，返回的是一个局部变量的值，此处是安全的cout << num2 << endl;    // 输出num2的值，即20int &num3 = plus10(num1); // 调用plus10函数，返回局部变量的引用并赋值给num3// 这里是危险的，因为num3现在引用了一个已经销毁的局部变量int &num4 = plus10(num3); // 再次调用plus10函数，返回局部变量的引用并赋值给num4// 这里同样是危险的，因为num4现在引用了一个已经销毁的局部变量cout << num3 << " " << num4 << endl; // 输出num3和num4的值，这是未定义行为return 0; // 程序结束，返回0
}

  运行结果：

  简单解释：事实上在编译的时候编译器已经发出了警告，其内容为返回了一个局部变量的引用。这是一个错误，因为局部变量在函数返回后就会销毁，返回的引用将指向一个不再有效的内存位置。

  在运行的时候直接出现“段错误”，从此可以看出，绝对不要使用引用去返回一个局部变量，否则将会出现程序崩溃的后果。

015引用初探_多级引用

  相关代码：

#include <iostream>int main(int argc, char const *argv[])
{int a = 10;  // 定义整型变量a并初始化为10int &r = a;  // 定义整型引用r，并初始化为a的引用int &rr = r; // 定义整型引用rr，并初始化为r的引用，即rr也是a的引用// 输出rr、r和a的值，由于rr和r都是a的引用，它们的值与a相同std::cout << "rr = " << rr << "\nr = " << r << "\na = " << a << std::endl;return 0;
}

  运行结果：

020引用与指针递增的区别

  相关代码：

#include <iostream>
using namespace std;int main(int argc, char const *argv[])
{int a = 10;        // 定义整型变量a并初始化为10int &r = a;        // 定义整型引用r，并初始化为a的引用r++;               // 通过引用r增加a的值std::cout << r << std::endl; // 输出r的值，即a的值，现在是11int arr[2] = {27, 84}; // 定义并初始化一个整型数组arr，包含两个元素27和84int *p = arr;          // 定义一个整型指针p，并初始化为指向数组arr的首地址p++;                   // 将指针p向后移动一个位置，指向数组arr的第二个元素std::cout << *p << std::endl;    // 输出指针p所指向的值，即数组arr的第二个元素，值为84return 0;
}

  运行结果：

030const与引用

  相关代码：

#include <iostream>/* 引用不能绑定到临时数据，但是当使用 const 关键字对引用加以限定后，引用就可以绑定到临时数据了。 */// 定义一个结构体S，包含两个整型成员a和b
typedef struct
{int a; // 成员aint b; // 成员b
} S;// 函数func_int，返回一个整型值100
int func_int()
{int n = 100; // 初始化整型变量n为100return n;    // 返回n的值
}// 函数func_s，返回一个结构体S的实例，其成员a和b分别被赋值为100和200
S func_s()
{S a;       // 定义结构体变量aa.a = 100; // 设置a的成员a为100a.b = 200; // 设置a的成员b为200return a;  // 返回结构体变量a
}// 重载+运算符，用于两个结构体S的实例相加
S operator+(const S &A, const S &B)
{S C;             // 定义结构体变量C，用于存储A和B相加的结果C.a = A.a + B.a; // 设置C的成员a为A和B的成员a之和C.b = A.b + B.b; // 设置C的成员b为A和B的成员b之和return C;        // 返回结构体变量C
}// 程序的入口点
int main()
{int m = 100, n = 36; // 定义并初始化整型变量m为100，n为36// 以下都是通过字面量或表达式初始化的常量引用，注意它们都没有实际的对象与之绑定const int &r1 = m + n;      // 常量引用r1绑定到m和n的和上const int &r2 = m + 28;     // 常量引用r2绑定到m和28的和上const int &r3 = 12 * 3;     // 常量引用r3绑定到12和3的乘积上const int &r4 = 50;         // 常量引用r4绑定到字面量50上const int &r5 = func_int(); // 常量引用r5绑定到函数func_int的返回值上S s1 = {23, 45}; // 定义并初始化结构体变量s1的成员a为23，b为45S s2 = {90, 75}; // 定义并初始化结构体变量s2的成员a为90，b为75const S &r6 = func_s(); // 常量引用r6绑定到函数func_s的返回值上const S &r7 = s1 + s2;  // 常量引用r7绑定到s1和s2的和上return 0; // 程序结束
}

  运行结果：

040使用const限定的函数形参引用

  相关代码：

#include <cstdio>// 计算长方体的表面积
// @param len 长方体的长度
// @param width 长方体的宽度
// @param hei 长方体的高度
// @return 返回长方体的表面积
/* 使用 const 能让函数接收 const 和非 const 类型的实参，否则将只能接收非 const 类型的实参； */
double volume(const double &len, const double &width, const double &hei)
{return len * width * 2 + len * hei * 2 + width * hei * 2;
}// 程序的入口点
int main()
{int a = 12, b = 3, c = 20; // 定义并初始化整型变量a为12，b为3，c为20double v1 = volume(a, b, c);                   // 调用volume函数计算长方体的表面积，并存储结果到v1double v2 = volume(10, 20, 30);                // 调用volume函数计算长方体的表面积，并存储结果到v2double v3 = volume(89.4, 32.7, 19);            // 调用volume函数计算长方体的表面积，并存储结果到v3double v4 = volume(a + 12.5, b + 23.4, 16.78); // 调用volume函数计算长方体的表面积，并存储结果到v4double v5 = volume(a + b, a + c, b + c);       // 调用volume函数计算长方体的表面积，并存储结果到v5printf("%lf, %lf, %lf, %lf, %lf\n", v1, v2, v3, v4, v5); // 打印出v1, v2, v3, v4, v5的值return 0;
}

  运行结果：