详解C++引用

---

前言

这篇文章是我写的第一篇文章，写的是C++中的引用。在刚开始接触引用时有诸多的疑惑，现在便总结一下，分享给对这方面有困惑的初学者，学艺不精，有什么错误还请指正。

一、引用的概念

引用啊简单来说就是给已存在的变量取个别名，比如说孙悟空绰号叫齐天大圣一样，但不管叫什么，他指代的都是同一个人，在代码中就是不管别名+本名有多少个，他们指的都是同一个变量。
引用有俩需要记忆的：
1如下图b是a的引用，如果修改了b那么a的内容也会被改变；
2a和b是共用同一个地址的，系统不会去另开空间。
使用方法
此时需要使用到我们在C语言中学习到的一个操作符叫做[&]，它是【按位与】，也是【取地址】，但是在C++中呢，它叫做【引用】
语法格式：
类型& 引用变量名（对象名）= 实体
例如

二、引用的五条特性

1 引用在定义的时候就必须进行初始化。
2 一个变量可以有多个引用。
3 一个引用可以继续有引用。
4 引用一旦初始化后就不能修改。
4 可以对任何类型引用。

1.引用在定义的时候就必须进行初始化

若定义了一个int&就必须初始化否则就会报错。例如：

2.一个变量可以有多个引用

说白了就是你可以对一个变量取好几个外号。例如：

此处b，c，d都是a的引用，修改其中任何一个的值，都会导致另外三个的值发生改变，此外这四个共用同一个地址。

3.一个引用可以继续有引用

即你可以b是a的引用，c又是b的引用。例如：

4.引用一旦初始化后就不能修改

字面意思，否则会发生重定义错误。例如：

5.可以对任何类型引用

以上举的例子我们都是对int的引用，我们也可以对double，float等等进行引用。

三、两种使用场景

1、做函数参数

在以前的C语言学习中我们在函数传参时学习过传值和传址的区别，一个最经典的例子就是交换两个数的值。

#include<iostream>

using namespace std;
void swap1(int* a, int* b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}
int main()
{
	int a = 10, b = 20;
	swap1(&a, &b);
	cout << a << endl << b << endl;
	return 0;
}

除了用指针之外我们还可以用引用来完成目的，因为引用是别名，修改了别名就相当于修改了本身。

#include<iostream>

using namespace std;
void swap2(int& a, int& b)
{
	int tmp;
	tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int a = 10, b = 20;
	swap2(a, b);
	cout << a << endl << b << endl;
	return 0;
}

可以看到达到了目的。所以如果你想要达到在函数中修改参数的值，在函数外也同时被修改的目的就可以用引用传参。
当然用指针也可以，但一般用引用会更好一点，这里简要说明原因：我们知道进行函数传参时，是需要进行拷贝的，例如在上面的图中，将main函数中的a传给swap中的参数’a‘就相当于把a的值拷贝给’a‘，当然如果只是拷贝一个int类型的变量那么这个拷贝付出的代价可以忽略不记，但我要是传一个有几万个数据的数组呢？这样传参的时候一个一个拷贝是不是就太费时间了，对吧。但如果使用引用的话，我们传的是变量a的一个别名，这样就避免了拷贝这一步，就可以省略时间，达到优化的目的。
最后我会讨论引用和指针的区别与联系。

2、做返回值

引用的另一大作用是充当函数的返回值。

传引用返回： 含义为返回 返回对象的别名。
传值返回：生成一个返回对象拷贝作为函数调用的返回值。

此处应该先补充一个简单的小知识，那就是返回值是如何返回的，我此处说的比较简单，如果大家想要深入研究的话就去看看函数栈帧这一块内容。
如以下的代码所示，当返回c的时候并不是直接把c的值赋值给ret的，由于c是一个零时变量，它在Add函数结束调用的时候就被释放掉了，所以在调用Add函数结束之后是不能将c的值赋值给ret的，因为这个时候c已经被释放了，现在c的值就不知道是什么了（可能改变了，也可能没变）。因此在Add函数调用结束之前它会把c的值暂时放到一个cpu中的寄存器中去，寄存器是独立于内存和系统之外的硬件，上一个函数直接取得该寄存器中的值即能得到返回值。（即在main函数中将寄存器里的值赋值给ret）

#include<iostream>
using namespace std;
int Add(int a,int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int a = 10, b = 20;
	int ret = Add(a, b);
	cout << ret << endl;
	return 0;
}

既然在返回时又涉及到了拷贝问题，（返回值拷贝给零时变量（寄存器），然后由这个零时变量进行返回）那么我们就可以用引用解决问题，引用避免了拷贝给零时变量，然后再由零时变量返回的问题，采用引用，我们就相当于直接把返回值的别名返回了。
这里有一个注意的问题就是我们用引用返回，不能返回零时变量
那让我们来看看返回零时变量会发生什么事情。

上面是用int ret接收返回值的，下面我们更进一步用int& ret来接收。ret是c引用的引用，说白了ret就是c，虽然函数调用结束后，c的内块空间已经被释放了，但我们依旧可以使用这种方法来访问这块空间。下面的代码本质上还是不对的，因为返回的是零时变量的引用。

#include<iostream>
using namespace std;
int& Add(int a,int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int a = 10, b = 20;
	int& ret = Add(a, b);
	cout << ret << endl;
	Add(1, 3);
	cout << ret << endl;
	return 0;
}

引用返回的正确使用方式
如果传引用返回的值是已经开辟好的，栈帧销毁了也不会影响的，那我们可以使用传引用返回，这样既可以访问到该地址处的值，同样也可以直接对其进行修改。

四、传值、传引用效率比较

1 函数传值与传引用

#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; 
}

可以看出传引用在数据较大的情况下效率会更高。

2 值与引用作为函数返回值

#include <time.h>
struct A { int a[10000]; };
//全局变量A
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;
}

结果显而易见，引用返回显然效率高。

五、 常引用

用const进行修饰后，改变量就成了只读型不准修改，不加const就是既可以读又可以修改。
权限平移

//权限平移可读可写-可读可写
int a = 10;
int& b = a;
//权限平移只读-只读
const int c = 10;
const int& d = c;

权限放大

//只读
const int a = 10;
//可读可写
int& b = a;//导致权限放大报错

权限缩小

//可读可写
int a = 10;
//只读
const int& b = a;//权限缩小不报错，可以

由此看来，权限可以平移也可以缩小但不能放大。另外值得注意的是零时变量具有”常性“（即和加了const限制一样），例如：

如图int& b=a是不正确的，相当于发生了权限放大，因为在进行隐式类型转换的时候a会产生一个零时变量，我们暂且把这个零时变量叫x，这个x是具有常性的，相当于前面加了const，因此必须用const int& c来接受
总结
权限只能缩小，不能放大，放大就会报错。
权限放大和缩小只针对引用和指针。
临时变量具有常属性。
const 引用具有非常强的接受度。
使用引用传参，函数内不改变参数，尽量使用 const 引用传参

六、指针和引用的区别

语法上引用是没有空间的，和引用实体使用同一块空间，但底层上来说是有的，因为引用其实底层就是用指针实现的。
不同点
1 引用概念上定义一个变量的别名，指针存储一个变量地址。
2 引用在定义时必须初始化，指针没有要求。
3 引用在初始化引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体。
4 没有 NULL 引用，但有 NULL 指针
5 在 sizeof 中含有不同：引用结果为未引用类型的大小，但指针始终是地址空间所占字节数(32为平台下占4个字节，64位平台下占8个字节)
6 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小。
7 有多级指针，但是没有多级引用

//可以这样
int a = 10;
int& b = a;
int& c = b;
//但不可以和指针一样这样
int&& d = a;

关于这个int&&，涉及到了左值，右值引用，我们以后有机会深入说。
8 访问实体方式不同，指针需要显示解引用，引用是编译器自己去处理。
9 引用比指针使用起来更加安全。