目录
一、引用定义
引用：给已经存在的变量取一个别名，并不是定义一个新变量。编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
ra就是a的引用，无论值还是地址都相同，使用同一块内存空间。
#include<iostream>
using namespace std;
void f()
{
int a = 10;
int& ra = a;
cout << "a = " << a << endl;
cout << "ra = " << ra << endl;
printf("&a : %p\n", &a);
printf("&ra : %p\n", &ra);
}
int main()
{
f();
return 0;
}
注意：引用类型必须和引用实体是类型相同
二、引用特性
1.引用在定义时必须初始化，不能为NULL
#include<iostream>
using namespace std;
void f()
{
int a = 10;
int& ra;//编译会报错，需要指定ra是谁的引用
}
int main()
{
f();
return 0;
}
2.一个变量可以有多个引用，即可以有多个别名
#include<iostream>
using namespace std;
void f()
{
int a = 10;
int& ra = a;
int& rb = a;
int& rc = ra;
cout << "ra = " << ra << endl;
cout << "rb = " << rb << endl;
cout << "rc = " << rb << endl;
}
int main()
{
f();
return 0;
}这块空间既叫做a，又叫做ra、rb、rc
（3）引用一旦引用一个实体，就不能再引用其它实体
三、常引用
1.常引用声明
常引用声明方式：const 类型& 引用变量名 = 目标变量名
#include <iostream>
using namespace std;
int main()
{
const int a = 10;
const int& ra = a;//正确常引用
int& ra1 = a;//错误常引用
return 0;
}int& ra1 = a是错误引用，是因为变量a使用了const关键字，表明a的值不能被修改。但ra1作为a的引用，并没有使用const关键字，说明ra1的值可以被修改，这会导致权限被放大，编译器不允许：
虽然权限放大不被允许，但是权限缩小是允许的：目标变量没有const关键字修饰，常引用使用const关键字修饰，如下所示：
#include <iostream>
using namespace std;
int main()
{
int b = 20;
const int& rb = b;
return 0;
}2.带有隐式类型转换的常引用
隐式类型转换：编译器自动将一种类型转换成另一种类型，是编译器的一种自主行为
在隐式类型转换过程中，会产生一个临时变量，类型为目标变量类型。
int c = 10;
double d = 1.11;
d = c;//隐式类型转换，将int类型赋值为double类型
带有隐式类型转换的常引用如下所示：
int c = 10;
const double& rc = c;//带有隐式类型转换的常引用，将int类型赋值为double类型（1）const修饰带有隐式类型转换引用的必要性
这是因为在隐式类型转换过程中，发生了类型赋值，这时候不是把c给rc，而是产生了一个临时变量，临时变量是double类型的。因此rc引用的并不是c，是这个过程中产生的临时变量，而临时变量具有常性，不可修改，因此rc要加上const关键字进行修饰。
（2）const修饰带有隐式类型转换引用的原因
如果rc不加const关键字进行修饰，rc引用临时变量，临时变量不可修改，但是rc又可读可写，那么rc即引用的权限就被放大了，这是不允许的。
监视可以看到程序执行完毕时，c的值并没有发生变化，d≠c，rc≠c，d和rc改变的是临时变量的值。
四、使用场景
1.做参数
引用可以做参数，可以代替指针的作用
如Swap函数，指针的写法如下，有多处使用"*"解引用
//指针写法
void Swap(int* left, int* right)
{
int temp = *left;
*left = *right;
*right = *left;
}如果用引用做参数，不需要解引用，不需要使用"*"
//引用写法
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = left;
}2.做返回值
先了解传值返回，再了解传引用返回
（1）传值返回
传值返回，返回的是返回对象c的拷贝，不拿c做返回值，c只是Add的临时变量，Add函数调用结束后，c就不在了，因此不能返回c，返回的是临时变量。
#include<iostream>
using namespace std;
int Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int ret = Add(1, 2);
return 0;
}如何证明产生了这个临时变量？如下，使用ret接收返回值
#include<iostream>
using namespace std;
int Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
return 0;
}但编译不通过
根据常引用声明，这是权限被放大导致的编译错误。c没有使用const进行修饰，ret也没有使用const进行修饰，为什么会导致权限放大呢？这是由于中间产生了临时变量，临时变量具有常性，不可修改。
所以ret也应该被const修饰，传引用返回的c的引用，即临时变量的名称，也是c的别名，把c的别名给了ret。
#include<iostream>
using namespace std;
int Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
cosnt int& ret = Add(1, 2);//用const修饰引用
return 0;
}传值返回生成的临时对象是需要返回的对象的拷贝：
①如果需要返回的对象比较小，一般会使用寄存器存储这个临时对象
②如果这个对象比较大，这个临时对象通常会存在于上一个函数的栈帧中。假如c比较大，那么临时对象会存在main函数中。
（2）传引用返回
传引用返回，返回的是返回对象c的引用(别名)，当调用完Add函数，return返回后，Add的栈帧被销毁了，但是它使用的内存空间还在，只是使用权不属于它了，所以再去访问那块内存空间时，内存空间有可能没被清空，也有可能被清空了，因此有可能是以前的值，也有可能是随机值，所以代码的运行结果是不确定的。
#include<iostream>
using namespace std;
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(5, 7);
cout << "ret = "<<ret << endl;
return 0;
}当调用Add(5,7) 时，调用的是同一个函数，在同一位置上再建立一个栈帧，栈帧大小是一样的，c的位置也一样，仅仅只是把c的位置的内容由3改成了12，因此ret的值也为12。
但如果调用Add(1,2) 后，下次调用的不是Add函数，是其他函数，那么c的位置的值会被改成其他内容。比如调用Add(1,2)后，再打印HelloWorld，那么会打印随机值。
#include<iostream>
using namespace std;
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
printf("Hello world\n");
cout << "ret = "<<ret << endl;
return 0;
}
因此实际中，如果出了函数作用域，返回对象就不存在了，不能用引用返回。如果非要用引用返回，就要使用static关键字，延长变量的生命周期，Add函数调用完毕，栈帧销毁，但是静态区不会销毁，栈帧销毁对函数局部变量没有影响。
#include<iostream>
using namespace std;
int& Add(int a, int b)
{
static int c = a + b;//栈帧销毁对c没有影响
return c;
}
int main()
{
const int& ret = Add(1, 2);
Add(5, 7);
cout << "ret = " << ret << endl;
return 0;
}什么时候使用传值返回，什么时候使用传引用返回呢？
如果函数返回时，出了函数作用域，如果返回对象还在（还没还给操作系统） ，可以使用引用返回，如果已经还给系统了，必须要用传值返回。
传值传参和传值返回、传引用传参和传引用返回
TestFunc1传值，TestFunc2传引用
#include<iostream>
#include<time.h>
using namespace std;
struct A
{
int a[10000];
};
void TestFunc1(A a)
{
}
void TestFunc2(A& a)
{
}
void TestRefAndValue()
{
A aa;
//以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; i++)
{
TestFunc1(aa);
}
size_t end1 = clock();
//以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; i++)
{
TestFunc2(aa);
}
size_t end2 = clock();
//分别计算两个函数运行结束后的时间
cout << "TestFun1(A)-time:" << end1 - begin1 << endl;
cout << "TestFun2(A)-time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
return 0;
}传值传参和传值返回：在传参和返回期间，形参是实参的一份拷贝，返回变量是变量本身的一份拷贝，实参和变量本身占多大空间，形参和返回变量就占多大空间，在函数内操作副本，对该变量的修改并不会修改函数外部的变量。
传引用传参：形参和实参是同一个东西，实际操作的就是该变量，由于引用是指向某个变量的，对引用的操作其实就是对他指向的变量的操作，因此函数内对变量进行修改的话，外部变量也会被相应修改。
如果不希望修改变量的值，需要选择传值而不是传引用。但传引用往往比传值效率要高。
五、引用和指针
int a = 10;
//引用：在语法上，这里给a这块空间取了一个别名，没有开辟新空间
int& ra = a;
ra = 20;
//指针：在语法上，这里定义了一个指针变量，开了4个字节空间，存储a的地址
int* pa = &a;
*pa = 20;1. 引用是别名，指针是地址
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体，指针可以被重新赋值以指向另一个不同的变量。
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全。 这是由于，从编译上看，程序在编译时分别将指针和引用添加到 符号表上，符号表上记录变量名、变量地址。指针变量在符号表上对应的地址值为指针变量的地址，而 引用在符号表上对应的地址值为 引用对象的地址值。符号表生成后就不会再更改，指针可以改变指向的对象（指针变量中的值可以改），而引用对象不能改（第（3）条）。因此引用比指针更安全。如：
int a= 10;
int b = 30;
int*& rpa = pa;//rpa是pa即int*的别名，此时pa指向a
rpa = &b;//rpa作为pa的引用，rpa的值被修改了，因此pa的值也被修改了，现在rpa和pa的值都为b的地址
printf("&a = %p\n", &a);
printf("&b = %p\n", &b);
printf("rpa = %p\n", rpa);
printf("pa = %p\n", pa);
643
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
