目录
一、引用概念
引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"。
类型& 引用变量名(对象名) = 引用实体；
|
void TestRef() { int a = 10; int& ra = a;//<====定义引用类型 int& rra=a; int& rrra=rra; printf("%p\n", &a); printf("%p\n", &ra); |
注意：引用类型必须和引用实体是同种类型的
二、引用特性
- 引用在定义时必须初始化// int& ra = a;初始化表明引用了a
- 一个变量可以有多个引用
- 引用一旦引用一个实体，再不能引用其他实体
|
void TestRef() { ??? ??? int a = 10; ?????? int b=20; ??? ??? // int& ra;// 该条语句编译时会出错 ?????? int& ra = a; ?????? int& rra = a; ?????? ra=b;//这里是把b的值赋值给了ra ?????? printf("%p %p %p\n", &a, &ra, &rra); ??? } |
三、常引用（有一点点像常变量）
|
void TestConstRef() {?? //1????????????????? ??? const int a = 10;（为左值） ??? //int& ra = a;??? // ra的类型是int,编译不通过因为a的类型为const int,是只读，ra的类型为int,也就是可读可写的，这是不允许的 (两者类型都为int) ??? const int& ra = a;//这样引用就可以了 ??? //2 ??? int c=1; ??? int &e=c; ??? const int&f=c;//这里是可以的，f只是读 //总结：引用取别名时，变量访问的权限可以缩小，不能放大 ??? //3 ??? // int& b = 10; // 该语句编译时会出错，b为常量 ??? const int& b = 10; ??? //4 ??? double d = 12.34; ??? //int& rd = d; // 该语句编译时会出错，类型不同（更确切的说是权限放大了） ??? const int& rd = d; ??? //补充1 ??? const int ar=10; ??? int br=ar;//不是隐式类型转换，都为int,只是简单的赋值，br的变化不会影响ar ??? //补充2 ??? const int * cp1=&a; ??? //int *p1=cp1;// 该语句编译时会出错,权限放大了 ??? //补充3 ??? int * cp1=&a;//a不为常变量 ??? const int *p1=cp1;// 权限缩小。可以 } |
四、使用场景
1、做参数
|
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> //指针 void swap_c(int*p, int*q) { ??? int tmp = *p; ??? *p = *q; ??? *q = tmp; } //引用 void swap_cpp(int &r1, int&r2) { ??? int tmp = r1; ??? r1 = r2; ??? r2 = tmp; } int main() { ??? int a = 10; ??? int b = 23; ??? swap_c(&a, &b); ??? swap_cpp(a, b); ??? return 0; } |
2、做返回值
|
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> int Count1() { ??? static int n = 0; ??? n++; ??? return n;//返回的是临时变量tmp，其中int tmp=n，会多创一个空间给tmp? } int& Count2() { ??? static int n = 0; ??? n++; ??? return n;//返回的是tmp，tmp是n的引用其中int& tmp=n ，因为n出了count2函数也不会被销毁 //则可以使用引用返回?? } int main() { ??? const int&r1 = Count1();//Count1()返回的tmp是临时变量，具有常属性，r1引用的是该临时变量 ??? int&r2 = Count2();//Count2()返回的是tmp，tmp是n的引用，因此r2也是n的引用，没有开辟空间给tmp,tmp是n的引用 ??? return 0; } |
|
#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; int& Add(int a, int b) { ??? int c = a + b; ??? /*static int c = 0; ??? ?c = a + b;;*/ ??? return c; } int main() { ??? int& ret = Add(1, 2);//ret指向了c的空间，此时c已经被销毁了 ??? Add(3, 4);//返回的c和第一次调用的c的空间恰好是同一个内存空间，因此ret的值变了 ??? //在release下会被优化，第二次调用创建的c和第一次的c不是同一个内存空间，因此ret的值未被修改 ??? //这样引用局部变量是不安全的，因为别人可以通过其它途径修改ret的值 ??? cout << "Add(1, 2) is :" << ret << endl;//ret为7 ??? return 0; } |
?注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
六、传值、传引用效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是 传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是? 当参数或者返回值类型非常大时，效率就更低。
七、值和引用的作为返回值类型的性能比较
|
#define _CRT_SECURE_NO_WARNINGS 1 #include <time.h> #include<iostream> using namespace std; struct A { ??? int a[10000]; }; A a; // 值返回 A TestFunc1() { ??? return a; } // 引用返回 A& TestFunc2() { ??? return a; } void TestReturnByRefOrValue() { ??? // 以值作为函数的返回值类型 ??? size_t begin1 = clock(); ??? for (size_t i = 0; i < 1000000; ++i) ?????? TestFunc1(); ??? size_t end1 = clock(); ??? // 以引用作为函数的返回值类型 ??? size_t begin2 = clock(); ??? for (size_t i = 0; i < 1000000; ++i) ?????? TestFunc2(); ??? size_t end2 = clock(); ??? // 计算两个函数运算完成之后的时间 ??? cout << "TestFunc1 time:" << end1 - begin1 << endl; ??? cout << "TestFunc2 time:" << end2 - begin2 << endl; } int main() { ??? TestReturnByRefOrValue(); ??? return 0; } |
通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。
使用引用便可以减少拷贝提高效率（当返回值足够大或者调用函数返回次数足够多这效率的提升的效果非常明显）
七、引用和指针的区别
在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。
在底层实现上实际是有空间的，因为引用是按照指针方式来实现的
|
int main() { ??? int a = 10; int& ra = a; ??? cout << "&a = " << &a << endl; ??? cout << "&ra = " << &ra << endl; ??? return 0; } |
|
int main() { ??? int a = 10; ??? int& ra = a; ??? ra = 20; ??? int* pa = &a; ??? *pa = 20; ??? return 0; } |
?我们来看下引用和指针的汇编代码对比：
?
八、引用和指针的不同点:
- 引用在定义时必须初始化，指针没有要求
- 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型 实体
- 没有NULL引用，但有NULL指针
- 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
- 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
- 有多级指针，但是没有多级引用
- 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
- 引用比指针使用起来相对更安全