• C++学习——引用详解

    以下内容源于C语言中文网的学习与整理，非原创，如有侵权请告知删除。

    一、引用的语法

    1、引用的含义

    引用（Reference）是 C++ 相对于C语言的又一个扩充。

    引用可以看做是数据的一个别名，通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式，一个可执行程序可以有多个快捷方式，通过这些快捷方式和可执行程序本身都能够运行程序；引用类似于人的绰号，使用绰号和本名都表示同一个人。

    2、引用的定义

    引用的定义方式如下：

    1. data_type &variable_name = value;
    2.  
    3. //data_type表示数据类型，比如int、char等等；
    4. //variable_name表示“引用”的名称；
    5. //value表示被引用的数据。
    6.  
    7. /*
    8. int a = 10;
    9. int &b = a;
    10. */

    （1）可见，引用的定义方式类似于指针，只是用&取代了*。你可以这样理解：忽略 & 这个符号本身的意义，这里提出了一个新的概念“引用”；指针表示某个变量的地址，引用表示这个变量本身。 

    （2）引用必须在定义的同时初始化，并且以后也要从一而终，不能再引用其它数据，有点类似于 const 变量。

    如何理解这句话呢？

    一开始我以为这句话是错的。比如下面的例子，我直观地认为：引用 r 一开始指向变量 a，后来（因为语句“ r = b; ”）改为指向变量 b ，运行也通过了。

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 99, b = 32;
    6. 	int &r = a;
    7. 	cout << a << ", " << r << endl; //输出99，99
    8. 	r = b;//这里进行修改，在VS2105下运行通过
    9. 	cout << b << ", " << r << endl; //输出32，32
    10.     getchar();
    11. 	return 0;
    12. }

    后来参考博客c++中引用一经定义不能更改转而引用其他变量的理解，才发现自己理解错误了。

    语句“r=b;”的含义，并非如我所理解的那样，把引用 r 的指向，由指向变量a改为指向变量b。它的含义，是给引用 r 赋予变量 b 的值，也就是相当于 r=32，引用 r 还是指向变量 a 的。

    为了验证这一点，可以修改变量 a 和 b 的值，看看引用 r 的值与哪个变量同步改变。如果引用 r 真的指向了变量 b，那么指向 r 的值应该与变量 b 同步更改。如下所示：

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 99, b = 32;
    6. 	int &r = a;
    7. 	cout << a << ", " << r << endl; //输出99，99
    8. 	r = b;
    9. 	cout <", "<< b << ", " << r << endl; //输出 ？，32，32
    10. 	
    11.     a = 44;
    12. 	b = 56;//这里将b的值修改为56
    13. 	//如果引用r指向b的话，那么r的值应该也是56。下句代码就应该输出56,56
    14. 	//如果引用r依然指向a的话，那么r的值应该是44。下句代码就应该输出56,44
    15.  
    16. 	cout << b << ", " << r << endl;
    17.  
    18. 	return 0;
    19. }
    1. 99, 99
    2. 32, 32, 32
    3. 56, 44

    结果说明，修改变量 b 并没有改变引用 r 的值，修改变量 a 则同步修改引用 r 的值。这说明了语句“r=b;”并不是改变引用 r 的指向，而是在给它赋值；而引用 r 还是在指向变量 a，真是“人生只如初见”啊！

    因此开头那句话，是这个意思：引用一旦绑定了某个变量，就终生绑定它了；虽然你可以修改这个引用的值（从而修改它所绑定的那个变量的值），但这仅仅是在修改引用的值或者说修改它绑定的那个变量的值，这个引用还是在绑定原来的那个变量。

    所谓“再引用其他数据”，应该是说下面这个形式，这是不允许的，编译不会通过：

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 99, b = 32;
    6. 	int &r = a;
    7.     a = 67;
    8. 	cout << a << ", " << r << endl; //67,67
    9.  
    10.     &r=b;//不能重新引用其他数据
    11.     b = 88;
    12. 	cout << b << ", " << r << endl;
    13.  
    14. 	return 0;
    15. }

    3、引用的示例 

    下面是一个演示引用的实例：

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5.     int a = 99;
    6.     int &r = a; //第6行
    7.     cout << a << ", " << r << endl;
    8.     cout << &a << ", " << &r << endl;//第8行
    9.  
    10.     return 0;
    11. }
    1. 99, 99
    2. 00B7FB00, 00B7FB00

    （1）本例中，变量 r 就是变量 a 的引用，它们用来指代同一份数据；也可以说变量 r 是变量 a 的另一个名字。

    （2）从输出结果可以看出，变量 a 和变量 r 的地址一样，都是00B7FB00；或者说地址为00B7FB00的内存有两个名字，a 和 r，想要访问该内存上的数据时，使用哪个名字都行。

    （3）引用在定义时需要添加&，在使用时不能添加&，使用时添加&表示取地址。上面第 6 行中的&表示引用，第 8 行中的&表示取地址。

    （4）由于引用 r 和原始变量 a 都是指向同一地址，所以通过引用也可以修改原始变量中所存储的数据，请看下面的例子： 

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5.     int a = 99;
    6.     int &r = a;
    7.     r = 47;
    8.     cout << a << ", " << r << endl;
    9.  
    10.     return 0;
    11. }

    最终程序输出两个 47，可见原始变量 a 的值已经被引用变量 r 所修改。如果不希望通过引用来修改原始的数据，那么可以在定义引用时，在前面添加 const 限制，这叫做“常引用”。形式如下：

    1. const data_type &variable_name = value;
    2. //或
    3. data_type const &varaible_name = value;

     比如下面编译时会报错：不能给常量r赋值。

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 99, b = 32;
    6. 	const int &r = a;
    7. 	cout << a << ", " << r << endl; 
    8. 	r = b;
    9. 	cout << b << ", " << r << endl; 
    10.     getchar();
    11. 	return 0;
    12. }

    二、引用作为函数参数

    在定义或声明函数时，我们可以将函数的形参指定为引用的形式，这样在调用函数时就会将实参和形参绑定在一起，让它们都指代同一份数据。如此一来，如果在函数体中修改了形参的数据，那么实参的数据也会被修改，从而拥有 “ 在函数内部影响函数外部数据 ” 的效果。

    一个能够展现按引用传参的优势的例子就是交换两个数的值，请看下面的代码：

    1. #include 
    2. using namespace std;
    3.  
    4. void swap1(int a, int b);
    5. void swap2(int *p1, int *p2);
    6. void swap3(int &r1, int &r2);
    7.  
    8.  
    9. int main() {
    10.     int num1, num2;
    11.     cout << "Input two integers: ";
    12.     cin >> num1 >> num2;
    13.     swap1(num1, num2);
    14.     cout << num1 << " " << num2 << endl;
    15.  
    16.     cout << "Input two integers: ";
    17.     cin >> num1 >> num2;
    18.     swap2(&num1, &num2);
    19.     cout << num1 << " " << num2 << endl;
    20.  
    21.     cout << "Input two integers: ";
    22.     cin >> num1 >> num2;
    23.     swap3(num1, num2);
    24.     cout << num1 << " " << num2 << endl;
    25.  
    26.     return 0;
    27. }
    28.  
    29. //直接传递参数内容
    30. void swap1(int a, int b) {
    31.     int temp = a;
    32.     a = b;
    33.     b = temp;
    34. }
    35.  
    36. //传递指针
    37. void swap2(int *p1, int *p2) {
    38.     int temp = *p1;
    39.     *p1 = *p2;
    40.     *p2 = temp;
    41. }
    42.  
    43. //按引用传参
    44. void swap3(int &r1, int &r2) {
    45.     int temp = r1;
    46.     r1 = r2;
    47.     r2 = temp;
    48. }
    1. Input two integers: 12 34↙
    2. 12 34
    3. Input two integers: 88 99↙
    4. 99 88
    5. Input two integers: 100 200↙
    6. 200 100

    （1）swap1() 直接传递参数的内容，不能达到交换两个数的值的目的。对于 swap1() 来说，a、b 是形参，是作用范围仅限于函数内部的局部变量，它们有自己独立的内存（位于栈区），和 num1、num2 指代的数据不一样。调用函数时分别将 num1、num2 的值传递给 a、b，此后 num1、num2 和 a、b 再无任何关系，在 swap1() 内部修改 a、b 的值不会影响函数外部的 num1、num2，更不会改变 num1、num2 的值。

    （2） swap2() 传递的是指针，能够达到交换两个数的值的目的。调用函数时，分别将 num1、num2 的指针传递给 p1、p2，此后 p1、p2 指向 a、b 所代表的数据，在函数内部可以通过指针间接地修改 a、b 的值。

    （3）swap3() 是按引用传递，能够达到交换两个数的值的目的。调用函数时，分别将 r1、r2 绑定到 num1、num2 所指代的数据，此后 r1 和 num1、r2 和 num2 就都代表同一份数据了，通过 r1 修改数据后会影响 num1，通过 r2 修改数据后也会影响 num2。

    从上面可以看出，按引用传参在使用形式上比指针更加直观。在以后的 C++ 编程中，建议读者大量使用引用，它一般可以代替指针（当然指针在C++中也不可或缺），C++ 标准库也是这样做的。

    三、引用作为函数返回值

    引用除了可以作为函数形参，还可以作为函数返回值，请看下面的例子：

    1. #include 
    2. using namespace std;
    3.  
    4. int &plus10(int &r) {
    5.     r += 10;
    6.     return r;
    7. }
    8.  
    9. int main() {
    10.     int num1 = 10;
    11.     int num2 = plus10(num1);
    12.     cout << num1 << " " << num2 << endl;
    13.  
    14.     return 0;
    15. }

    运行结果是输出“20 20”。

    这里函数返回变量 r的数据类型是“int &”，因此返回值的数据类型也（建议）是“int &”。

    在将引用作为函数返回值时应该注意一个小问题，就是不能返回局部数据（例如局部变量、局部对象、局部数组等）的引用，因为当函数调用完成后局部数据就会被销毁，有可能在下次使用时数据就不存在了，C++ 编译器检测到该行为时也会给出警告。

    比如更改上面的例子，让 plus10() 返回一个局部数据的引用：

    1. #include 
    2. using namespace std;
    3.  
    4. int &plus10(int &r) {
    5.     int m = r + 10;
    6.     return m;  //返回局部数据的引用
    7. }
    8.  
    9. int main() {
    10.     int num1 = 10;
    11.     int num2 = plus10(num1);
    12.     cout << num2 << endl;
    13.     int &num3 = plus10(num1);
    14.     int &num4 = plus10(num3);
    15.     cout << num3 << " " << num4 << endl;
    16.  
    17.     return 0;
    18. }

    在 Visual Studio 下的运行结果：

    1. 20
    2. -858993450 -858993450

    在 GCC 下的运行结果：

    1. C:\Users\XJH\Desktop>g++ 1.cpp
    2. 1.cpp: 在函数‘int& plus10(int&)’中:
    3. 1.cpp:5:9: 警告：reference to local variable ‘m’ returned [-Wreturn-local-addr]
    4.      int m = r + 10;
    5.          ^
    6.  
    7. C:\Users\XJH\Desktop>

    而我们期望的运行结果是：

    1. 20
    2. 20 30

    plus10() 返回一个对局部变量 m 的引用，这是导致运行结果非常怪异的根源。因为函数是在栈上运行的，并且运行结束后会放弃对所有局部数据的管理权，后面的函数调用会覆盖前面函数的局部数据。本例中，第二次调用 plus10() 会覆盖第一次调用 plus10() 所产生的局部数据，第三次调用 plus10() 会覆盖第二次调用 plus10() 所产生的局部数据。

    四、引用的本质

    这里先给出结论：引用只是对指针进行了简单的封装，它的底层依然是通过指针实现的。

    我们看一下之前的例子：

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5.     int a = 99;
    6.     int &r = a; //第6行
    7.     cout << a << ", " << r << endl;
    8.     cout << &a << ", " << &r << endl;//第8行
    9.  
    10.     return 0;
    11. }
    1. 99, 99
    2. 00B7FB00, 00B7FB00

    上面的例子表明，我们通过 &r 所获取的地址，不是变量 r 的地址，而是变量 a 的地址。这似乎说明 r 这个变量不占用独立的内存，它和 a 指代的是同一份内存。

    但我们要明白，变量是要占用内存的，因此变量 r 肯定也占用内存。那为何使用 &r 获取不到变量 r 的地址呢？下面将进行说明，这里先给出答案：编译器不让我们获取变量 r 的内存地址。

    我们看下面的例子：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int num = 99;
    6.  
    7. class A{
    8. public:
    9.     A();//类A的构造函数
    10. private:
    11.     int n;
    12.     int &r;//定义了一个引用r
    13. };
    14.  
    15. //构造函数的定义
    16. A::A(): n(0), r(num){}//将0赋值给成员变量n，将全局变量num赋值给引用r
    17.  
    18. int main (){
    19.     A *a = new A();
    20.     cout<<sizeof(A)<//输出A类型的大小
    21.     cout<int*)a + 1)<//输出r本身的内容
    22.     cout<<&num<//输出num变量的地址
    23.  
    24.     return 0;
    25. }
    1. 8
    2. 0x8ab000
    3. 008AB000

    （1）从输出结果可知，A类型的大小是8字节，这说明成员变量 r 是占用内存的，如果不占用的话，sizeof(A)的结果应该为 4 字节。

    （2）hex表示以十六进制输出，showbase表示添加十六进制前缀0x。

    （3）变量 r 存储的内容是0x8ab000，也即变量 num 的地址。

    （4）第（3）点说明 r 的实现和指针非常类似。如果将 r 定义为int *类型的指针，并在构造函数中让它指向 num，那么 r 占用的内存也是 4 个字节，存储的内容也是 num 的地址。如下所示：

    1. #include 
    2. #include 
    3. using namespace std;
    4.  
    5. int num = 99;
    6.  
    7. class A{
    8. public:
    9.     A();//类A的构造函数
    10. private:
    11.     int n;
    12.     int *r;
    13. };
    14.  
    15. //构造函数的定义
    16. A::A(): n(0), r(&num){}
    17.  
    18. int main (){
    19.     A *a = new A();
    20.     cout<<sizeof(A)<//输出A类型的大小
    21.     cout<int*)a + 1)<//输出r本身的内容
    22.     cout<<&num<//输出num变量的地址
    23.  
    24.     return 0;
    25. }
    1. 8
    2. 0x13b000
    3. 0013B000

    指针变量 r 的内存地址（即&r）处存放着变量 num 的地址（即&num）（这句话的意思就是，变量r的值是变量num的地址，即r=&num），因此我们通过 &r 可以获取变量 r 的内存地址，然后*(&r)得到&num（也就是 r=&num），然后*r获取num的值，如下所示。

    从以上分析可知，其实引用只是对指针进行了简单封装，它的底层依然是通过指针实现的，引用占用的内存和指针占用的内存长度一样，在 32 位环境下是 4 个字节，在 64 位环境下是 8 个字节。

    之所以不能获取引用的地址，是因为编译器进行了内部转换。

    以下面的语句为例： 

    1. int a = 99;
    2. int &r = a;
    3. r = 18;
    4. cout<<&r<

     编译时会被转换成如下的形式：

    1. int a = 99;
    2. int *r = &a;
    3. *r = 18;
    4. cout<

    使用&r取地址时，编译器会对代码进行隐式的转换，使得代码输出的是 r 的内容（a 的地址），而不是 r 的地址，这就是为什么获取不到引用变量的地址的原因。也就是说，不是变量 r 不占用内存，而是编译器不让获取它的地址。

    当引用作为函数参数时，也会有类似的转换。以下面的代码为例：

    1. //定义函数
    2. void swap(int &r1, int &r2){
    3.     int temp = r1;
    4.     r1 = r2;
    5.     r2 = temp;
    6. }
    7.  
    8. //调用函数
    9. int num1 = 10, num2 = 20;
    10. swap(num1, num2);

    编译时会被转换成如下的形式：

    1. //定义函数
    2. void swap(int *r1, int *r2){
    3.     int temp = *r1;
    4.     *r1 = *r2;
    5.     *r2 = temp;
    6. }
    7.  
    8. //调用函数
    9. int num1 = 10, num2 = 20;
    10. swap(&num1, &num2);

    引用虽然是基于指针实现的，但它比指针更加易用，从上面的两个例子也可以看出来，通过指针获取数据时需要加*，书写麻烦，而引用不需要，它和普通变量的使用方式一样。

    C++ 的发明人 Bjarne Stroustrup 也说过，他在 C++ 中引入引用的直接目的是为了让代码的书写更加漂亮，尤其是在运算符重载中，不借助引用有时候会使得运算符的使用很麻烦。 

    上面扯那么多，简单总结就是：

    下次你遇到一个引用 int &r = num，由于编译器的内部转换，输出&r 的效果等同于输出 &num。

    或者由于编译器的内部转换，可以把引用 r 彻底等同于 num，因此 &r 等同于 &num。

    五、引用和指针的区别

    1、引用必须在定义时初始化，并且以后也要从一而终，不能再指向其他数据；指针没有这个限制，指针在定义时不必赋值，以后也能指向任意数据。（见“一、引用的语法”的描述。）

    2、有const指针但没有const引用，因为 r 本来就不能改变指向，加上const是多此一举，因此下面的写法是错误的。

    1. int a = 20;
    2. int & const r = a;

    这个说法貌似不对？请看下面的例子1,2,3。 

    （1）例子1

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 20;
    6. 	int & const r = a;
    7. 	cout << r << endl;
    8. 	getchar();
    9.  
    10. 	return 0;
    11. }

    在VS2015下，输出结果 20。

    在GCC环境下，输出内容如下：

    1. C:\Users\XJH\Desktop>g++ 1.cpp
    2. 1.cpp: 在函数‘int main()’中:
    3. 1.cpp:6:14: 错误：‘const’限定符不能应用到‘int&’上
    4.   int & const r = a;
    5.               ^
    6.  
    7. C:\Users\XJH\Desktop>

    （2）例子2

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 20, b = 32;
    6. 	int & const r = a;
    7. 	cout << r << endl;
    8. 	r = b;
    9. 	cout << r << endl;
    10. 	return 0;
    11. }

    在VS2015中输出结果如下：（将r进行const修饰后居然还可以修改r的值！是不是因为const的位置不对？按照“一、引用的语法”中常引用那样修改（例子3），则不可以修改r的值）

    1. 20
    2. 32

    在GCC环境下输出结果依然如下：

    1. C:\Users\XJH\Desktop>g++ 1.cpp
    2. 1.cpp: 在函数‘int main()’中:
    3. 1.cpp:7:14: 错误：‘const’限定符不能应用到‘int&’上
    4.   int & const r = a;
    5.               ^
    6.  
    7. C:\Users\XJH\Desktop>

    （3）例子3

    1. #include 
    2. using namespace std;
    3.  
    4. int main() {
    5. 	int a = 20, b = 32;
    6. 	const int &r = a;
    7. 	cout << r << endl;
    8. 	r = b;
    9. 	cout << r << endl;
    10. 	return 0;
    11. }

    在VS2015中报错：不能给常量r赋值。

    在GCC中报错如下：

    1. C:\Users\XJH\Desktop>g++ 1.cpp
    2. 1.cpp: 在函数‘int main()’中:
    3. 1.cpp:8:6: 错误：向只读形参‘r’赋值
    4.   r = b;
    5.       ^
    6.  
    7. C:\Users\XJH\Desktop>

    从上面的这些例子可以看出：

    引用是可以加const修饰的，但是const这个修饰符的位置，不能放在&和变量之间（不能写成int & const r=b），可以写成：

    1. int b = 10;
    2. const int &r = b;//或者写成int const &r = b;

    3、指针可以有多级，但是引用只能有一级。例如int **p是合法的，而int &&r是不合法的。

    如果希望定义一个引用变量来指代另外一个引用变量，那么也只需要加一个&，如下所示：

    1. int a = 10;
    2. int &r = a;
    3. int &rr = r;

    4、指针和引用的自增（++）自减（--）运算意义不一样。对指针使用 ++ 表示指向下一份数据，对引用使用 ++ 表示它所指代的数据本身加 1；自减（--）也是类似的道理。请看下面的例子：

    1. #include 
    2. using namespace std;
    3.  
    4. int main (){
    5.     int a = 10;
    6.     int &r = a;
    7.     r++;
    8.     cout<//输出11
    9.    
    10.     int arr[2] = { 27, 84 };
    11.     int *p = arr;
    12.     p++;
    13.     cout<<*p<//输出84
    14.  
    15.     return 0;
    16. }

    六、引用不能绑定到临时数据

    我们知道，指针就是数据或代码在内存中的地址，指针变量指向的就是内存中的数据或代码。这里有一个关键词需要强调，就是内存，指针只能指向内存，不能指向寄存器或者硬盘，因为寄存器和硬盘没法寻址。

    其实 C++ 代码中的大部分内容都是放在内存中的，例如定义的变量、创建的对象、字符串常量、函数形参、函数体本身、new或malloc()分配的内存等，这些内容都可以用&来获取地址，进而用指针指向它们。除此之外，还有一些我们平时不太留意的临时数据，例如表达式的结果、函数的返回值等，它们可能会放在内存中，也可能会放在寄存器中。一旦它们被放到了寄存器中，就没法用&获取它们的地址了，也就没法用指针指向它们了。

    下面的代码演示了表达式所产生的临时结果：

    1. int n = 100, m = 200;
    2. int *p1 = &(m + n);    //m + n 的结果为 300
    3. int *p2 = &(n + 100);  //n + 100 的结果为 200
    4. bool *p4 = &(m < n);   //m < n 的结果为 false

    这些表达式的结果都会被放到寄存器中，尝试用&获取它们的地址都是错误的。

    下面的代码演示了函数返回值所产生的临时结果：

    1. int func(){
    2.     int n = 100;
    3.     return n;
    4. }
    5.  
    6. int *p = &(func());

    func() 的返回值 100 也会被放到寄存器中，也没法用&获取它的地址。

    1、什么样的临时数据会放到寄存器中

    寄存器离 CPU 近，并且速度比内存快，将临时数据放到寄存器是为了加快程序运行。但是寄存器的数量是非常有限的，容纳不下较大的数据，所以只能将较小的临时数据放在寄存器中。int、double、bool、char 等基本类型的数据往往不超过 8 个字节，用一两个寄存器就能存储，所以这些类型的临时数据通常会放到寄存器中；而对象、结构体变量是自定义类型的数据，大小不可预测，所以这些类型的临时数据通常会放到内存中。

    下面的代码是正确的，它证明了结构体类型的临时数据会被放到内存中：

    1. #include 
    2. using namespace std;
    3.  
    4. typedef struct{
    5.     int a;
    6.     int b;
    7. } S;
    8.  
    9. //这里用到了一点新知识，叫做运算符重载，我们会在《运算符重载》一章中详细讲解
    10. S operator+(const S &A, const S &B){
    11.     S C;
    12.     C.a = A.a + B.a;
    13.     C.b = A.b + B.b;
    14.     return C;
    15. }
    16.  
    17. S func(){
    18.     S a;
    19.     a.a = 100;
    20.     a.b = 200;
    21.     return a;
    22. }
    23.  
    24. int main(){
    25.     S s1 = {23, 45};
    26.     S s2 = {90, 75};
    27.     S *p1 = &(s1 + s2);
    28.     S *p2 = &(func());
    29.     cout<", "<
    30.  
    31.     return 0;
    32. }

    2、关于常量表达式

    诸如 100、200+34、34.5*23、3+7/3 等不包含变量的表达式称为常量表达式（Constant expression）。

    常量表达式由于不包含变量，没有不稳定因素，所以在编译阶段就能求值。编译器不会分配单独的内存来存储常量表达式的值，而是将常量表达式的值和代码合并到一起，放到虚拟地址空间中的代码区。从汇编的角度看，常量表达式的值就是一个立即数，会被“硬编码”到指令中，不能寻址。

    总起来说，常量表达式的值虽然在内存中，但是没有办法寻址，所以也不能使用&来获取它的地址，更不能用指针指向它。下面的代码是错误的，它证明了不能用&来获取常量表达式的地址：

    1. int *p1 = &(100);
    2. int *p2 = &(23 + 45 * 2);

    3、引用也不能指代临时数据

    引用和指针在本质上是一样的，引用仅仅是对指针进行了简单的封装。引用和指针都不能绑定到无法寻址的临时数据，并且 C++ 对引用的要求更加严格，在某些编译器下甚至连放在内存中的临时数据都不能指代。

    下面的代码中，我们将引用绑定到了临时数据：

    1. typedef struct{
    2.     int a;
    3.     int b;
    4. } S;
    5.  
    6. int func_int(){
    7.     int n = 100;
    8.     return n;
    9. }
    10.  
    11. S func_s(){
    12.     S a;
    13.     a.a = 100;
    14.     a.b = 200;
    15.     return a;
    16. }
    17.  
    18. //这里用到了一点新知识，叫做运算符重载，我们会在《运算符重载》一章中详细讲解
    19. S operator+(const S &A, const S &B){
    20.     S C;
    21.     C.a = A.a + B.a;
    22.     C.b = A.b + B.b;
    23.     return C;
    24. }
    25.  
    26. int main(){
    27.     //下面的代码在GCC和Visual C++下都是错误的
    28.     int m = 100, n = 36;
    29.     int &r1 = m + n;
    30.     int &r2 = m + 28;
    31.     int &r3 = 12 * 3;
    32.     int &r4 = 50;
    33.     int &r5 = func_int();
    34.    
    35.     //下面的代码在GCC下是错误的，在Visual C++下是正确的
    36.     S s1 = {23, 45};
    37.     S s2 = {90, 75};
    38.     S &r6 = func_s();
    39.     S &r7 = s1 + s2;
    40.  
    41.     return 0;
    42. }

    第 28~33 行代码在 GCC 和 Visual C++ 下都不能编译通过，第 38~39 行代码在 Visual C++ 下能够编译通过，但是在 GCC 下编译失败。这说明：

    • 在 GCC 下，引用不能指代任何临时数据，不管它保存到哪里；
    • 在 Visual C++ 下，引用只能指代位于内存中（非代码区）的临时数据，不能指代寄存器中的临时数据。

    4、引用作为函数参数

    当引用作为函数参数时，有时候很容易给它传递临时数据。下面的 isOdd() 函数用来判断一个数是否是奇数：

    1. bool isOdd(int &n){
    2.     if(n%2 == 0){
    3.         return false;
    4.     }else{
    5.         return true;
    6.     }
    7. }
    8.  
    9. int main(){
    10.     int a = 100;
    11.     isOdd(a);  //正确
    12.     isOdd(a + 9);  //错误
    13.     isOdd(27);  //错误
    14.     isOdd(23 + 55);  //错误
    15.  
    16.     return 0;
    17. }

    isOdd() 函数用来判断一个数是否为奇数，它的参数是引用类型，只能传递变量，不能传递常量或者表达式。但用来判断奇数的函数不能接受一个数字又让人感觉很奇怪，所以类似这样的函数应该坚持使用值传递，而不是引用传递。

    下面是更改后的代码：

    1. bool isOdd(int n){  //改为值传递
    2.     if(n%2 == 0){
    3.         return false;
    4.     }else{
    5.         return true;
    6.     }
    7. }
    8.  
    9. int main(){
    10.     int a = 100;
    11.     isOdd(a);  //正确
    12.     isOdd(a + 9);  //正确
    13.     isOdd(27);  //正确
    14.     isOdd(23 + 55);  //正确
    15.  
    16.     return 0;
    17. }

    七、编译器会为const引用创建临时变量 

    上节我们讲到，引用不能绑定到临时数据，这在大多数情况下是正确的，但是当使用 const 关键字对引用加以限定后，引用就可以绑定到临时数据了。下面的代码演示了引用和 const 这一对神奇的组合：

    1. typedef struct{
    2.     int a;
    3.     int b;
    4. } S;
    5.  
    6. int func_int(){
    7.     int n = 100;
    8.     return n;
    9. }
    10.  
    11. S func_s(){
    12.     S a;
    13.     a.a = 100;
    14.     a.b = 200;
    15.     return a;
    16. }
    17.  
    18. S operator+(const S &A, const S &B){
    19.     S C;
    20.     C.a = A.a + B.a;
    21.     C.b = A.b + B.b;
    22.     return C;
    23. }
    24.  
    25. int main(){
    26.     int m = 100, n = 36;
    27.     const int &r1 = m + n;
    28.     const int &r2 = m + 28;
    29.     const int &r3 = 12 * 3;
    30.     const int &r4 = 50;
    31.     const int &r5 = func_int();
    32.  
    33.     S s1 = {23, 45};
    34.     S s2 = {90, 75};
    35.     const S &r6 = func_s();
    36.     const S &r7 = s1 + s2;
    37.  
    38.     return 0;
    39. }

    这段代码在 GCC 和 Visual C++ 下都能够编译通过，这是因为将常引用绑定到临时数据时，编译器采取了一种妥协机制：编译器会为临时数据创建一个新的、无名的临时变量，并将临时数据放入该临时变量中，然后再将引用绑定到该临时变量。注意，临时变量也是变量，所有的变量都会被分配内存。

    为什么编译器为常引用创建临时变量是合理的，而为普通引用创建临时变量就不合理呢？

    （1）我们知道，将引用绑定到一份数据后，就可以通过引用对这份数据进行操作了，包括读取和写入（修改）；尤其是写入操作，会改变数据的值。而临时数据往往无法寻址，是不能写入的，即使为临时数据创建了一个临时变量，那么修改的也仅仅是临时变量里面的数据，不会影响原来的数据，这样就使得引用所绑定到的数据和原来的数据不能同步更新，最终产生了两份不同的数据，失去了引用的意义。 

    以下面的例子进行说明：

    1. void swap(int &r1, int &r2){
    2.     int temp = r1;
    3.     r1 = r2;
    4.     r2 = temp;
    5. }

    如果编译器会为 r1、r2 创建临时变量，那么函数调用swap(10, 20)就是正确的，但是 10 不会变成 20，20 也不会变成 10，所以这种调用是毫无意义的。

    总起来说，不管是从“引用的语义”这个角度看，还是从“实际应用的效果”这个角度看，为普通引用创建临时变量都没有任何意义，所以编译器不会这么做。 

    （2）const 引用和普通引用不一样，我们只能通过 const 引用读取数据的值，而不能修改它的值，所以不用考虑同步更新的问题，也不会产生两份不同的数据，为 const 引用创建临时变量反而会使得引用更加灵活和通用。

    以上节的 isOdd() 函数为例：

    1. bool isOdd(const int &n){  //改为常引用
    2.     if(n/2 == 0){
    3.         return false;
    4.     }else{
    5.         return true;
    6.     }
    7. }

    由于在函数体中不会修改 n 的值，所以可以用 const 限制 n，这样一来，下面的函数调用就都是正确的了：

    1. int a = 100;
    2. isOdd(a);  //正确
    3. isOdd(a + 9);  //正确
    4. isOdd(27);  //正确
    5. isOdd(23 + 55);  //正确

    对于第 2 行代码，编译器不会创建临时变量，会直接绑定到变量 a；对于第 3~5 行代码，编译器会创建临时变量来存储临时数据。也就是说，编译器只有在必要时才会创建临时变量。

    八、const引用与转换类型

    不同类型的数据占用的内存数量不一样，处理方式也不一样，指针的类型要与它指向的数据的类型严格对应。下面的例子演示了错误的指针使用方式：

    1. int n = 100;
    2. int *p1 = &n;  //正确
    3. float *p2 = &n;  //错误
    4. char c = '@';
    5. char *p3 = &c;  //正确
    6. int *p4 = &c;  //错误

    虽然 int 可以自动转换为 float，char 也可以自动转换为 int，但是float *类型的指针不能指向 int 类型的数据，int *类型的指针也不能指向 char 类型的数据。

    为什么「编译器禁止指针指向不同类型的数据」是合理的呢？

    以 int 类型的数据和float *类型的指针为例，我们让float *类型的指针强制指向 int 类型的数据，看看会发生什么。下面的代码演示了这一幕： 

    1. #include 
    2. using namespace std;
    3. int main(){
    4.     int n = 100;
    5.     float *p = (float*)&n;
    6.     *p = 19.625;
    7.     printf("%d\n", n);
    8.     return 0;
    9. }

    将 float 类型的数据赋值给 int 类型的变量时，会直接截去小数部分，只保留整数部分，本例中将 19.626 赋值给 n，n 的值应该为 19 才对，这是我们通常的认知。但是本例的输出结果是一个毫无意义的数字，它与 19 没有任何关系，这颠覆了我们的认知。

    虽然 int 和 float 类型都占用 4 个字节的内存，但是程序对它们的处理方式却大相径庭：

    • 对于 int，程序把最高 1 位作为符号位，把剩下的 31 位作为数值位；
    • 对于 float，程序把最高 1 位作为符号位，把最低的 23 位作为尾数位，把中间的 8 位作为指数位。

    关于整数和小数在内存中的存储形式，我们已在《整数在内存中是如何存储的》《小数在内存中是如何存储的》两节中讲到，不了解的读者请猛击链接学习。

    n 存储的二进制位是不变的，只是当以不同的形式展现出来的时候，我们看到的结果是不一样的。读者可以尝试通过printf("%f\n", *p);输出 n 的值，得到的结果就是 19.625000。

    让指针指向「相关的（相近的）但不是严格对应的」类型的数据，表面上看起来是合理的，但是细思极恐，这样会给程序留下很多意想不到的、难以发现的 Bug，所以编译器禁止这样做是非常合理的。当然，如果你想通过强制类型转换达到这个目的（如上例所示），那编译器也会放任不管，给你自由发挥的余地。

    引用（Reference）和指针（Pointer）在本质上是一样的，引用仅仅是对指针进行了简单的封装，「类型严格一致」这条规则同样也适用于引用。下面的例子演示了错误的引用使用方式： 

    1. int n = 100;
    2. int &r1 = n;  //正确
    3. float &r2 = n;  //错误
    4.  
    5. char c = '@';
    6. char &r3 = c;  //正确
    7. int &r4 = c;  //错误

    1、const 引用与类型转换

    「类型严格一致」是为了防止发生让人匪夷所思的操作，但是这条规则仅仅适用于普通引用，当对引用添加 const 限定后，情况就又发生了变化，编译器允许引用绑定到类型不一致的数据。请看下面的代码：

    1. int n = 100;
    2. int &r1 = n;  //正确
    3. const float &r2 = n;  //正确
    4.  
    5. char c = '@';
    6. char &r3 = c;  //正确
    7. const int &r4 = c;  //正确

    当引用的类型和数据的类型不一致时，如果它们的类型是相近的，并且遵守「数据类型的自动转换」规则，那么编译器就会创建一个临时变量，并将数据赋值给这个临时变量（这时候会发生自动类型转换），然后再将引用绑定到这个临时的变量，这与「将 const 引用绑定到临时数据时」采用的方案是一样的。

    注意，临时变量的类型和引用的类型是一样的，在将数据赋值给临时变量时会发生自动类型转换。请看下面的代码：

    1. float f = 12.45;
    2. const int &r = f;
    3. printf("%d", r);

    该代码的输出结果为 12，说明临时变量和引用的类型都是 int（严格来说引用的类型是 int &），并没有变为 float。

    当引用的类型和数据的类型不遵守「数据类型的自动转换」规则，那么编译器将报错，绑定失败，例如：

    1. char *str = "http://c.biancheng.net";
    2. const int &r = str;

    char *和int两种类型没有关系，不能自动转换，这种引用就是错误的。

    结合上节讲到的知识，总结起来说，给引用添加 const 限定后，不但可以将引用绑定到临时数据，还可以将引用绑定到类型相近的数据，这使得引用更加灵活和通用，它们背后的机制都是临时变量。

    2、引用类型的函数形参请尽可能的使用 const

    当引用作为函数参数时，如果在函数体内部不会修改引用所绑定的数据，那么请尽量为该引用添加 const 限制。

    下面的例子演示了 const 引用的灵活性：

    1. #include 
    2. using namespace std;
    3.  
    4. double volume(const double &len, const double &width, const double &hei){
    5.     return len*width*2 + len*hei*2 + width*hei*2;
    6. }
    7.  
    8. int main(){
    9.     int a = 12, b = 3, c = 20;
    10.     double v1 = volume(a, b, c);
    11.     double v2 = volume(10, 20, 30);
    12.     double v3 = volume(89.4, 32.7, 19);
    13.     double v4 = volume(a+12.5, b+23.4, 16.78);
    14.     double v5 = volume(a+b, a+c, b+c);
    15.     printf("%lf, %lf, %lf, %lf, %lf\n", v1, v2, v3, v4, v5);
    16.  
    17.     return 0;
    18. }

    运行结果：
    672.000000, 2200.000000, 10486.560000, 3001.804000, 3122.000000

    volume() 函数用来求一个长方体的体积，它可以接收不同类型的实参，也可以接收常量或者表达式。

    概括起来说，将引用类型的形参添加 const 限制的理由有三个：

    • 使用 const 可以避免无意中修改数据的编程错误；
    • 使用 const 能让函数接收 const 和非 const 类型的实参，否则将只能接收非 const 类型的实参；
    • 使用 const 引用能够让函数正确生成并使用临时变量。
  • 相关阅读:
    数字世界的艺术家_1024特别纪念篇
    架构师之路八分布式系统下大流量限流与消峰的方案
    USB摄像头驱动分析
    缺少比较器，运放来救场！（运放当做比较器电路记录）
    智能化小区管理系统(JSP+java+springmvc+mysql+MyBatis)
    初学者指南: 使用NumPy数组进行图像处理
    Stable Diffusion科普文章【附升级gpt4.0秘笈】
    NO8---蓝桥杯JAVA--- 斐波那契升级版
    Redis 先写数据库及先写缓存一致性问题
    密钥、证书原理与创建
  • 原文地址：https://blog.csdn.net/oqqHuTu12345678/article/details/133834081