第3章 C++引用总结
引用是C++的新增内容,在实际开发中会经常使用;C++引用就如同C语言的指针一样重要,但它比指针更加方便和易用。
我们知道,参数的传递本质上是一次赋值的过程,赋值就是对内存进行拷贝。所谓内存拷贝,是指将一块内存上的数据复制到另一块内存上。
- 对于像 char、bool、int、float 等基本类型的数据,它们占用的内存往往只有几个字节,对它们进行内存拷贝非常快速。
- 而数组、结构体、对象是一系列数据的集合,数据的数量没有限制,可能很少,也可能成千上万,对它们进行频繁的内存拷贝可能会消耗很多时间,拖慢程序的执行效率。
C/C++ 禁止在函数调用时直接传递数组的内容,而是强制传递数组指针,而对于结构体和对象没有这种限制,调用函数时既可以传递指针,也可以直接传递内容;为了提高效率,我曾建议传递指针,这样做在大部分情况下并没有什么不妥。但是在 C++ 中,我们有了一种比指针更加便捷的传递聚合类型数据的方式,那就是引用(Reference)。
引用(Reference)是 C++ 相对于C语言的又一个扩充。引用可以看做是数据的一个别名,通过这个别名和原来的名字都能够找到这份数据。引用类似于 Windows 中的快捷方式,一个可执行程序可以有多个快捷方式,通过这些快捷方式和可执行程序本身都能够运行程序;引用还类似于人的绰号(笔名),使用绰号(笔名)和本名都能表示一个人。
引用的定义方式类似于指针,只是用&取代了*,语法格式为:
type &name = data;
type 是被引用的数据的类型,name 是引用的名称,data 是被引用的数据。
引用必须在定义的同时初始化,并且以后也要从一而终,不能再引用其它数据,这有点类似于常量(const 变量)。
#include <iostream> using namespace std; int main(){ int a = 99; int &b = a; cout<<a<<", "<<b<<endl; cout<<&a<<", "<<&b<<endl; return 0; }
如果读者不希望通过引用来修改原始的数据,那么可以在定义时添加 const 限制,形式为:
const type &name = value;
这种引用方式为常引用。
引用除了可以作为函数形参,还可以作为函数返回值,在将引用作为函数返回值时应该注意一个小问题,就是不能返回局部数据(例如局部变量、局部对象、局部数组等)的引用,因为当函数调用完成后局部数据就会被销毁,有可能在下次使用时数据就不存在了,C++ 编译器检测到该行为时也会给出警告。
#include <iostream> using namespace std; int &plus10(int &n){ int m = n + 10; return m; //返回局部数据的引用 } int main(){ int num1 = 10; int num2 = plus10(num1); cout<<num2<<endl; int &num3 = plus10(num1); int &num4 = plus10(num3); cout<<num3<<" "<<num4<<endl; return 0; }
- 在 Visual Studio 下的运行结果:
plus10() 返回一个对局部变量 m 的引用,这是导致运行结果非常怪异的根源,因为函数是在栈上运行的,并且运行结束后会放弃对所有局部数据的管理权,后面的函数调用会覆盖前面函数的局部数据。本例中,第二次调用 plus10() 会覆盖第一次调用 plus10() 所产生的局部数据,第三次调用 plus10() 会覆盖第二次调用 plus10() 所产生的局部数据。
#include <iostream> using namespace std; int main(){ int a = 99; int &b = a; cout<<a<<", "<<b<<endl; cout<<&a<<", "<<&b<<endl; return 0; }
- mingw64运行结果如下:
- vs2022运行结果如下:
我们知道,变量是要占用内存的,虽然我们称 b 为变量,但是通过&b获取到的却不是 b 的地址,而是 a 的地址,这会让我们觉得 b 这个变量不占用独立的内存,它和 a 指代的是同一份内存。
请读者再继续看下面的例子:(个人:64位指针占用8个字节,还有可能涉及到内存对齐问题,所以将类型int改为了long long)
#include <iostream> #include <iomanip> using namespace std; long long num = 99; class A{ public: A(); private: long long n; long long &r; }; A::A(): n(1), r(num){} int main (){ A *a = new A(); cout<<"sizeof(long):"<<sizeof(long)<<endl; cout<<"sizeof(long long):"<<sizeof(long long)<<endl; cout<<"sizeof(A):"<<sizeof(A)<<endl; //输出A类型的大小 cout<<hex<<showbase<<*((long long *)a + 1)<<endl; //输出r的内容 cout<<&num<<endl; //输出num变量的地址 return 0; }
- 成员变量 r 是 private 属性的,不能直接通过对象来访问,但是借助强大的指针和类型转换,我们依然可以得到它的内容,只不过这种方法有点蹩脚,只要知道第 16 行代码是用来输出 r 的内容的即可。
- 第 18行代码中,hex表示以十六进制输出,showbase表示添加十六进制前缀0x。
从运行结果可以看出:
- 成员变量 r 是占用内存的,如果不占用的话,sizeof(A)的结果应该为 8。
- r 存储的内容也即变量 num 的地址。
这说明r的实现和指针非常类似。如果将 r 定义为long long *类型的指针,并在构造函数中让它指向 num,那么 r 占用的内存也是 8 个字节,存储的内容也是 num 的地址。
其实引用只是对指针进行了简单的封装,它的底层依然是通过指针实现的,引用占用的内存和指针占用的内存长度一样,在 32 位环境下是 4 个字节,在 64 位环境下是 8 个字节,之所以不能获取引用的地址,是因为编译器进行了内部转换。以下面的语句为例:
int a = 99; int &r = a; r = 18; cout<<&r<<endl;
编译时会被转换成如下的形式:
int a = 99; int *r = &a; *r = 18; cout<<r<<endl;
使用&r取地址时,编译器会对代码进行隐式的转换,使得代码输出的是 r 的内容(a 的地址),而不是 r 的地址,这就是为什么获取不到引用变量的地址的原因。也就是说,不是变量 r 不占用内存,而是编译器不让获取它的地址。
当引用作为函数参数时,也会有类似的转换。以下面的代码为例:
//定义函数 void swap(int &a, int &b){ int temp = a; a = b; b = temp; } //调用函数 int num1 = 10, num2 = 20; swap(num1, num2);
编译时会被转换成如下的形式:
//定义函数 void swap(int *a, int *b){ int temp = *a; *a = *b; *b = temp; } //调用函数 int num1 = 10, num2 = 20; swap(&num1, &num2);
引用虽然是基于指针实现的,但它比指针更加易用,通过指针获取数据时需要加*,书写麻烦,而引用不需要,它和普通变量的使用方式一样。C++ 的发明人 Bjarne Stroustrup 也说过,他在 C++ 中引入引用的直接目的是为了让代码的书写更加漂亮,尤其是在运算符重载中,不借助引用有时候会使得运算符的使用很麻烦。
引用和指针的其他区别是:
- 引用必须在定义时初始化,并且以后也要从一而终,不能再指向其他数据;而指针没有这个限制,指针在定义时不必赋值,以后也能指向任意数据。
- 可以有 const 指针,但是没有 const 引用。也就是说,引用变量不能定义为下面的形式:
int a = 20; int & const r = a;
因为 r 本来就不能改变指向,加上 const 是多此一举。
- 指针可以有多级,但是引用只能有一级,例如,int **p是合法的,而int &&r是不合法的。如果希望定义一个引用变量来指代另外一个引用变量,那么也只需要加一个&,如下所示:
int a = 10; int &r = a; int &rr = r;
- 指针和引用的自增(++)自减(--)运算意义不一样。对指针使用 ++ 表示指向下一份数据,对引用使用 ++ 表示它所指代的数据本身加 1;自减(--)也是类似的道理。请看下面的例子:
#include <iostream> using namespace std; int main (){ int a = 10; int &r = a; r++; cout<<r<<endl; int arr[2] = { 27, 84 }; int *p = arr; p++; cout<<*p<<endl; return 0; }
我们知道,指针就是数据或代码在内存中的地址,指针变量指向的就是内存中的数据或代码。这里有一个关键词需要强调,就是内存,指针只能指向内存,不能指向寄存器或者硬盘,因为寄存器和硬盘没法寻址。
- 其实 C++ 代码中的大部分内容都是放在内存中的,例如定义的变量、创建的对象、字符串常量、函数形参、函数体本身、new或malloc()分配的内存等,这些内容都可以用&来获取地址,进而用指针指向它们。
- 除此之外,还有一些我们平时不太留意的临时数据,例如表达式的结果、函数的返回值等,它们可能会放在内存中,也可能会放在寄存器中。一旦它们被放到了寄存器中,就没法用&获取它们的地址了,也就没法用指针指向它们了。(个人:对于引用也一样,因为引用的底层是根据指针来实现的)
下面的代码演示了表达式所产生的临时结果:
这些表达式的结果都会被放到寄存器中,尝试用&获取它们的地址都是错误的。(个人:似乎我们能够取得一个左值的地址,而对于一个右值,我们不能取得它的地址,它没有地址)
下面的代码演示了函数返回值所产生的临时结果:
func() 的返回值也会被放到寄存器中,也没法用&获取它的地址。
#include <iostream> using namespace std; typedef struct { int a; int b; } S; //这里用到了一点新知识,叫做运算符重载,我们会在《运算符重载》一章中详细讲解 S operator+(const S& A, const S& B) { S C; C.a = A.a + B.a; C.b = A.b + B.b; return C; } S func() { S a; a.a = 100; a.b = 200; return a; } int main() { S s1 = { 23, 45 }; S s2 = { 90, 75 }; S* p1 = &(s1 + s2); S* p2 = &(func()); cout << p1 << ", " << p2 << endl; return 0; }
诸如100、200+34、34.5*23、3+7/3 等不包含变量的表达式称为常量表达式(Constant expression)。常量表达式由于不包含变量,没有不稳定因素,所以在编译阶段就能求值。编译器不会分配单独的内存来存储常量表达式的值,而是将常量表达式的值和代码合并到一起,放到虚拟地址空间中的代码区。从汇编的角度看,常量表达式的值就是一个立即数,会被“硬编码”到指令中,不能寻址。
总起来说,常量表达式的值虽然在内存中,但是没有办法寻址,所以也不能使用&来获取它的地址,更不能用指针指向它。下面的代码是错误的,它证明了不能用&来获取常量表达式的地址:
引用和指针在本质上是一样的,引用仅仅是对指针进行了简单的封装。引用和指针都不能绑定到无法寻址的临时数据,并且C++对引用的要求更加严格,在某些编译器下甚至连放在内存中的临时数据都不能指代。
当引用作为函数参数时,有时候很容易给它传递临时数据。
上节我们讲到,引用不能绑定到临时数据,这在大多数情况下是正确的,但是当使用 const 关键字对引用加以限定后,引用就可以绑定到临时数据了。下面的代码演示了引用和 const 这一对神奇的组合:
#include <iostream> using namespace std; typedef struct { int a; int b; } S; int func_int() { int n = 100; return n; } S func_s() { S a; a.a = 100; a.b = 200; return a; } S operator+(const S& A, const S& B) { S C; C.a = A.a + B.a; C.b = A.b + B.b; return C; } int main() { int m = 100, n = 36; const int& r1 = m + n; const int& r2 = m + 28; const int& r3 = 12 * 3; const int& r4 = 50; const int& r5 = func_int(); S s1 = { 23, 45 }; S s2 = { 90, 75 }; const S& r6 = func_s(); const S& r7 = s1 + s2; cout<<"r1:"<<r1<<endl<<"r2:"<<r2<<endl<<"r3:"<<r3<<endl<<"r4:"<<r4<<endl <<"r5:"<<r5<<endl<<"r6:"<<r6.a<<" "<<r6.b<<endl<<"r7:"<<r7.a<<" "<<r7.b<<endl; return 0; }
这是因为将常引用绑定到临时数据时,编译器采取了一种妥协机制:编译器会为临时数据创建一个新的、无名的临时变量,并将临时数据放入该临时变量中,然后再将引用绑定到该临时变量。注意,临时变量也是变量,所有的变量都会被分配内存。
为什么编译器为常引用创建临时变量是合理的,而为普通引用创建临时变量就不合理呢?
- 我们知道,将引用绑定到一份数据后,就可以通过引用对这份数据进行操作了,包括读取和写入(修改);尤其是写入操作,会改变数据的值。而临时数据往往无法寻址,是不能写入的,即使为临时数据创建了一个临时变量(个人:这个临时变量保存在内存中),那么修改的也仅仅是临时变量里面的数据,不会影响原来的数据(个人:可能保存在寄存器中,无法寻址),这样就使得引用所绑定到的数据和原来的数据不能同步更新,最终产生了两份不同的数据,失去了引用的意义(个人:这个是从引用的语义角度来看),以swap() 函数为例:
void swap(int &a, int &b){ int temp = a; a = b; b = temp; }
如果编译器会为 a、b 创建临时变量,那么函数调用swap(10, 20)就是正确的,但是 10 不会变成 20,20 也不会变成 10,所以这种调用是毫无意义的。(个人:这里是从引用的实际应用的效果来看)
总起来说,不管是从“引用的语义”这个角度看,还是从“实际应用的效果”这个角度看,为普通引用创建临时变量都没有任何意义,所以编译器不会这么做。
- const 引用和普通引用不一样,我们只能通过 const 引用读取数据的值,而不能修改它的值,所以不用考虑同步更新的问题,也就不会产生两份不同的数据,为 const 引用创建临时变量反而会使得引用更加灵活和通用。以上节的 isOdd() 函数为例:
bool isOdd(const int &n){ //改为常引用 if(n/2 == 0){ return false; }else{ return true; } }
这样,下面的函数调用就是正确的了,
int a = 100; isOdd(a); //正确 isOdd(a + 9); //正确 isOdd(27); //正确 isOdd(23 + 55); //正确
对于第 2 行代码,编译器不会创建临时变量,会直接绑定到变量 a;对于第 3~5 行代码,编译器会创建临时变量来存储临时数据。也就是说,编译器只有在必要时才会创建临时变量。
不同类型的数据占用的内存数量不一样,处理方式也不一样,指针的类型要与它指向的数据的类型严格对应。下面的例子演示了错误的指针使用方式:
int n = 100; int *p1 = &n; //正确 float *p2 = &n; //错误 char c = '@'; char *p3 = &c; //正确 int *p4 = &c; //错误
虽然 int 可以自动转换为 float,char 也可以自动转换为 int,但是float *类型的指针不能指向 int 类型的数据,int *类型的指针也不能指向 char 类型的数据。
为什么「编译器禁止指针指向不同类型的数据」是合理的呢?
以 int 类型的数据和float *类型的指针为例,我们让float *类型的指针强制指向 int 类型的数据,看看会发生什么。下面的代码演示了这一幕:
#include <cstdio> using namespace std; int main(){ int n = 100; float *p = (float*)&n; *p = 19.625; printf("%d\n", n); return 0; }
将 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。
这里不能使用n,
让指针指向「相关的(相近的)但不是严格对应的」类型的数据,表面上看起来是合理的,但是细思极恐,这样会给程序留下很多意想不到的、难以发现的 Bug,所以编译器禁止这样做是非常合理的。当然,如果你想通过强制类型转换达到这个目的(如上例所示),那编译器也会放任不管,给你自由发挥的余地。
引用(Reference)和指针(Pointer)在本质上是一样的,引用仅仅是对指针进行了简单的封装,「类型严格一致」这条规则同样也适用于引用。下面的例子演示了错误的引用使用方式:
「类型严格一致」是为了防止发生让人匪夷所思的操作,但是这条规则仅仅适用于普通引用,当对引用添加 const 限定后,情况就又发生了变化,编译器允许引用绑定到类型不一致的数据。请看下面的代码:
当引用的类型和数据的类型不一致时,如果它们的类型是相近的,并且遵守「数据类型的自动转换」规则,那么编译器就会创建一个临时变量,并将数据赋值给这个临时变量(这时候会发生自动类型转换),然后再将引用绑定到这个临时的变量,这与「将 const 引用绑定到临时数据时」采用的方案是一样的。注意,临时变量的类型和引用的类型是一样的,在将数据赋值给临时变量时会发生自动类型转换。请看下面的代码:
float f = 12.45; const int &r = f; printf("%d", r);
该代码的输出结果为 12,说明临时变量和引用的类型都是 int(严格来说引用的类型是 int &),并没有变为 float。
当引用的类型和数据的类型不遵守「数据类型的自动转换」规则,那么编译器将报错,绑定失败,例如:
const char *和int两种类型没有关系,不能自动转换,这种引用就是错误的。
结合上节讲到的知识,总结起来说,给引用添加 const 限定后,不但可以将引用绑定到临时数据,还可以将引用绑定到类型相近的数据,这使得引用更加灵活和通用,它们背后的机制都是临时变量。
当引用作为函数参数时,如果在函数体内部不会修改引用所绑定的数据,那么请尽量为该引用添加 const 限制。
下面的例子演示了 const 引用的灵活性:
#include <cstdio> using namespace std; 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; double v1 = volume(a, b, c); double v2 = volume(10, 20, 30); double v3 = volume(89.4, 32.7, 19); double v4 = volume(a+12.5, b+23.4, 16.78); double v5 = volume(a+b, a+c, b+c); printf("%lf, %lf, %lf, %lf, %lf\n", v1, v2, v3, v4, v5); return 0; }
概括起来说,将引用类型的形参添加 const 限制的理由有三个:
- 使用 const 可以避免无意中修改数据的编程错误;
- 使用 const 能让函数接收 const 和非 const 类型的实参,否则将只能接收非 const 类型的实参;
- 使用 const 引用能够让函数正确生成并使用临时变量。