Let’s Make C++ Great Again——引用
目录
- 引用
-
- 引用概念
- 引用特性
- 引用的应用
-
- 传参
- 传返回值
- 效率比较
- 引用与指针的区别
- 引用经常与const搭配使用
引用
我使用引用还是比较频繁的,有一个直观的感觉:引用简化了一层指针的使用。
提前纠正一下之前的错误:
引用不能被引用,原因:引用只能引用实体,而引用本身不是实体
这句话是错误的。
#include using namespace std;int main(){int c = 10;int& b = c;int& d = b;cout << d;return 0;}
引用概念
引用不是新定义一个变量,而是给已存在变量取了一个别名,编译器不会为引用变量开辟内存空间,它和它
引用的变量共用同一块内存空间。
使用样式:类型& 别名 = 实体;
ps:引用类型必须和引用实体是同种类型的
引用特性
-
引用在定义时必须初始化
-
一个变量可以有多个引用
-
引用一旦引用一个实体,再不能引用其他实体
我们发现b
的地址没有发生改变,发生改变的只是a
的值。
b = c
进行的只是赋值操作,这个例子存在的意义就在于说明引用和指针的区别。
引用的应用
传参
#include using namespace std;void swap(int* a, int* b) // 在我们不知道引用前使用的{ int c = *a; *a = *b; *b = c;} void swap(int& a, int& b) // 了解引用后使用的{ int c = a; a = b; b = c;}int main(){ int a = 1, b = 2; swap(&a, &b); swap(a, b); return 0;}
ps:显而易见的是,引用版本更简洁
- 与函数重载的碰撞
这三个交换函数没有报错,实现了函数重载,原因:参数类型不同
ps:虽然引用的底层是依赖指针实现的,但是在编写时,我们依旧认为这是两种不同的类型。
但是调用会报错。
原因:引用版本与逻辑错误版本在函数的调用上存在歧义。
传返回值
形式如下:
#include using namespace std;int c;int& add(int a, int b){c = a + b;return c;}int main(){int t = add(1, 2);return 0;}#include using namespace std;int& add(int a, int b) // 将返回值引用改掉,在add(1, 2) = 4处会报错,//原因:传值返回,会产生临时变量,临时变量具有常性(为右值),不可修改。{static int c = a + b;return c;}int main(){add(1, 2) = 4;int t = add(1, 2);return 0;}
突然想起以前经常犯的错误:
int& add(int a, int b){int c = a + b;return c;}int main(){int ret = add(1, 2);return 0;}
首先明确一下这个变量c会存到哪里?
- 如果c比较小(4或8字节),一般是在寄存器中充当临时变量。
- 如果c比较大,临时变量放在调用add函数的栈帧中。
这里的引用返回的意思是,不会生成c的拷贝返回,而是直接返回c的引用。
当前代码的问题:
存在非法访问,因为add(1, 2)的返回值是c的引用,所以add栈帧销毁了以后,回去访问c位置空间。如果add函数栈帧销毁,清理空间,那么取c值的时候取到就是随机值,给ret的就是随机值,当前这个取决于编译器实现。
例子:
#include using namespace std;int& add(int a, int b){int c = a + b;return c;}int main(){int& ret = add(1, 2);cout << ret << endl;cout << "//" << endl;cout << ret << endl;return 0;}
结果:
总结:如果函数返回时,出了函数作用域,如果返回对象还未还给系统,则可以使用引用返回,如果已经还给系统了,则必须使用传值返回。
效率比较
以值作为参数或者返回值类型,在传参和返回期间,函数不会直接传递实参或者将变量本身直接返回,而是传递实参或者返回变量的一份临时的拷贝,因此用值作为参数或者返回值类型,效率是非常低下的,尤其是当参数或者返回值类型非常大时,效率就更低。
#include #include using namespace std;struct A { int a[10000]; };void Func1(A a) {}void Func2(A& a) {}int main(){A a;size_t begin1 = clock();for (size_t i = 0; i < 10000; ++i)Func1(a);size_t end1 = clock();size_t begin2 = clock();for (size_t i = 0; i < 10000; ++i)Func2(a);size_t end2 = clock();cout << "Func1(A)-time:" << end1 - begin1 << endl;cout << "Func2(A&)-time:" << end2 - begin2 << endl;return 0;}
结果:
#include #include using namespace std;struct A { int a[10000]; };A a;A Func1() {return a;}A& Func2() {return a;}int main(){size_t begin1 = clock();for (size_t i = 0; i < 10000; ++i)Func1();size_t end1 = clock();size_t begin2 = clock();for (size_t i = 0; i < 10000; ++i)Func2();size_t end2 = clock();cout << "Func1(A)-time:" << end1 - begin1 << endl;cout << "Func2(A&)-time:" << end2 - begin2 << endl;return 0;}
结果:
引用与指针的区别
逻辑上直观感觉:
在语法概念上引用就是一个别名,没有独立空间,和其引用实体共用同一块空间。
在底层实现上实际是有空间的,因为引用是按照指针方式来实现的。
我们可以通过一段代码的反汇编来观察出来:
#include using namespace std;int main(){int a = 10;int& b = a;int* c = &a;return 0;}
引用和指针的不同点:
- 引用在定义时必须初始化,指针没有要求
- 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型
实体 - 没有NULL引用,但有NULL指针
- 在sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占
4个字节) - 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小
- 有多级指针,但是没有多级引用
- 访问实体方式不同,指针需要显式解引用,引用编译器自己处理
- 引用比指针使用起来相对更安全
引用经常与const搭配使用
理论上,const Type&
是可以接受任何类型的参数的。
但是我们在书写下面这个例子时发生了错误:
为什么?
原因:C++无法用double
类型的值初始化int
类型的引用,因为double
在转化成int
时会发生隐式类型转换,产生了一个临时变量(临时变量是常值,不可修改)。想要以b来修改a变量位置的数据是不能够的了。无法引用一个肯定的不可更改的临时变量。
类同于:
修改一下即可(加入const):
原因就是:临时变量是常值。
我在阅读其他人的代码时也经常见到:const 与 & 的搭配
。
建议:使用引用传参,如果函数中不改变参数的值,建议使用const &。
因为:const限制了权限,更安全,&更具效率。
这里还有一个关于权限的问题:
#include using namespace std;int main(){// 权限不可放大const int a = 10;// int& b = a; 可以理解:明明a被设置是不可写的,难道一引用就可写了吗?// 权限可不变const int c = 20;const int& d = c;// 权限可放小int e = 30;const int& f = e;return 0;}
开发者涨薪指南 48位大咖的思考法则、工作方式、逻辑体系