目录
1.引用的概念
2.引用的性质
3.常量引用
4.使用场景
1.作参数
2.作返回值
5.传值与传引用的效率比较
6.值和引用作为返回值的性能比较
7.引用与指针
指针与引用的不同点
前言
要说C语言中哪个知识点最难学难懂，大部分人可能和我一样的答案——指针。C++既然是C语言的豪华升级版肯定要优化这一问题。不过指针虽然难，但是不得不说它确实牛*呀，指针使C语言变得更加灵活更加万能，可以说指针是C/C++的精髓，因此取缔指针是万万不能的，所以C++的祖师爷引进了引用的概念。
正文
1.引用的概念
引用：给已经存在的变量取个别名；编译器不会为引用变量开辟新的内存空间，它和引用的变量共用同一块内存空间；
例如：小明的小名叫作明明，不管是“明明”还是“小明”都指的是同一个人；
格式：类型& 引用变量名 = 被引用的实体；
//例如 ra 为 a 的引用 int a = 0; int& ra = a;
比较一下两个变量的地址是否相同；
//比较二者的地址 cout << &a << endl; cout << &ra << endl;
2.引用的性质
1.引用变量的类型与引用实体的类型要相同；
int a = 0; int& ra = a; char ch = 'a'; char& rch = ch;
2.引用在定义时必须初始化；
int a = 0; int& ra = a; //int& ra; //错误的写法
3.一个变量可以有多个引用；
int a = 0; int& b = a; int& c = a; //...
4.引用变量只能引用一个实体。
int a = 0; int b = 0; int& ra = a; ra = b; //不能再引用其他变量 //对比指针 int* pa = &a; pa = &b;
3.常量引用
引用常量时记得用 const 修饰，因为指针、引用在赋值或初始化时，权限可以缩小不能放大。
//1. const int a = 0; //int& ra = a; //编译时会报错，a为常量//权限放大 const int& ra = a; //权限保持 //int& b = 10; //错误写法，10为常量//权限放大 int c = 0; const int& rc = c; //权限缩小 //2. int Count() { int a = 0; return a + 1; } int main() { //int& ret = Count(); //编译错误，Count 返回值为常量 const int& ret = Count(); return 0; } //3. int a = 0; //double& b = a; //类型错误 //double& b = (double)a; //编译错误，类型转换时会产生临时变量 const double& b = (double)a; //证明产生的临时变量具有常量性质
4.使用场景
目前看来，引用好像并没有什么用，接下来看一下引用经常用到的场景。
1.作参数
//形参的改变会影响实参，因为形参为实参的别名 void Swap(int& a, int& b) { int tmp = a; a = b; b = tmp; } //对比指针 void Swap(int* a, int* b) { int tmp = *a; *a = *b; *b = tmp; }
//顺序表 typedef struct SeqList { int* a; int size; int capacity; }SL; void SLPushBack(SL* ps, int data);//C语言中 void SLpushBack(SL& rs, int data);//C++中
//单链表 typedef struct Node { int data; struct Node* next; }Node,*PNode; void SLTPushBack(Node** pphead, int data);//C语言中 void SLTPushBack(Node*& phead, int data);//C++中 void SLTPushBack(PNode& phead, int data);//C++中
2.作返回值
引用作返回值时，如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
int& Count() { static int n = 0;//出了作用域并未销毁，可用引用返回 n++; return n; }
int& Add(int a, int b) { int c = a + b;//c出了作用域会被销毁，引用返回不可用 return c; } int main() { int& ret = Add(1, 2); Add(3, 4); cout << "Add(1, 2) is :" << ret << endl;//看似结果为3，实则不然 return 0; }
引用作函数返回值时，调用函数时可修改返回对象；
#include<assert.h> #define N 10 typedef struct Array { int a[N]; int size = N; }Array; int& Test(Array& a, int i) { assert(i < N); return a.a[i]; } int main() { Array a; for (int i = 0; i < N; i++) { Test(a, i) = i * 10; } for (int i = 0; i < N; i++) { cout << Test(a, i) << " "; } cout << endl; return 0; }
5.传值与传引用的效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
//一组测试代码 #include <time.h> struct A { int a[10000]; }; void TestFunc1(A a) {} void TestFunc2(A& a) {} void TestRefAndValue() { A a; // 以值作为函数参数 size_t begin1 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc1(a); size_t end1 = clock(); // 以引用作为函数参数 size_t begin2 = clock(); for (size_t i = 0; i < 10000; ++i) TestFunc2(a); size_t end2 = clock(); // 分别计算两个函数运行结束后的时间 cout << "TestFunc1(A)-time:" << end1 - begin1 << endl; cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; } int main() { TestRefAndValue(); return 0; }
6.值和引用作为返回值的性能比较
//一组测试代码 #include <time.h> 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 < 100000; ++i) TestFunc1(); size_t end1 = clock(); // 以引用作为函数的返回值类型 size_t begin2 = clock(); for (size_t i = 0; i < 100000; ++i) TestFunc2(); size_t end2 = clock(); // 计算两个函数运算完成之后的时间 cout << "TestFunc1 time:" << end1 - begin1 << endl; cout << "TestFunc2 time:" << end2 - begin2 << endl; } int main() { TestReturnByRefOrValue(); return 0; }
7.引用与指针
引用与指针的用法及原理在我们使用者看来是不相同的（引用是给变量取别名，指针是指向变量的地址），但是其实引用的底层实现就是以指针的方式实现的。例如：
int main() { int a = 10; int& ra = a; ra = 20; int* pa = &a; *pa = 20; return 0; }
对比一下指针与引用的汇编代码，发现二者完全相同。
那么既然底层实现相同，我们是不是就不用区别引用和指针了呢？当然不是，底层实现相同可不关咱们使用者什么事，在使用时我们依旧要注意二者的区别。
指针与引用的不同点
1. 引用概念上定义一个变量的别名，指针存储一个变量地址；
2. 引用在定义时必须初始化，指针没有要求；
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体；
4. 没有 NULL 引用，但有 NULL 指针；
5. 在 sizeof 中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)；
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；
7. 有多级指针，但是没有多级引用；
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理；
9. 引用比指针使用起来相对更安全。
