一、引用概念

引用不是新定义一个变量，而是给已存在变量取一个别名，编译器不会为引用变量开辟内存空间，它和引用的变量共用一块内存空间。

比如：鲁迅，原名“周树人“，笔名“鲁迅”，小说里又称自己为”迅哥“。

类型&引用变量名（对象名）= 引用实体；

#include<iostream>
using namespace std;

void test_1()
{
	int a = 1;
	int& ra = a;
	cout << a << endl << ra << endl;
	cout << &a << endl << &ra << endl;
}

int main()
{
	test_1();
	return 0;
}

输出结果为：

表示 a 与 ra 的值一样，址一样。

注意：引用变量必须和引用实体是同种类型的。下面这种引用就不行：

二、引用特性

1. 引用在定义时必须初始化

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

3. 引用一旦引用一个实体，再不能引用其他实体

#include<iostream>
using namespace std;

void test_1()
{
	int a = 1;
	//int& ra;//会报错
	int& ra = a;
	int& rra = a;
	int b = 2;
	cout << a << endl << ra << endl << rra << endl;
	cout << &a << endl << &ra << endl << &rra << endl;
}

int main()
{
	test_1();
	return 0;
}

输出结果为：

表示 a，ra，rra的值与址都相同。

三、常引用

#include<iostream>
using namespace std;

void test_1()
{
	int a = 1;
	//int& ra = a;//会报错,a为常量
	const double& ra = a;
	a = 2;//a可修改
	//ra = 2;//ra不可修改
	//int& b = 10;//会报错,b为常量
	const int &b = 2;
	double d = 12.34;
	const int& rd = d;
}

int main()
{
	test_1();
	return 0;
}

通过上述代码可以看到，当常引用：const int& a = b 时，b可修改，由于是a是b的引用，b修改时a也会随之修改，但是不可对a直接修改。

四、使用场景

1. 做参数

void swap(int& a,int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}

int main()
{
	int a = 1, b = 2;
	swap(a, b);
	return 0;
}

2. 做返回值

int& count()
{
	static int a = 1;
	a++;
	return a;
}

引用做返回值的时候，在一些情况下会出现问题。下面举一个例子来说明一下，且看以下代码：

#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(3,4);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

此时输出的结果是多少呢？我们来看一下：

结果为7，诶？ret 明明就是Add(1,2)的返回值的引用啊，应该是3才对，为什么结果会是Add(3,4)的返回值呢？这个时候就要用函数栈帧的知识来解释了。

下面画了张分析图：

由这张图仔细分析可知，第一次 Add 操作后，返回值所在的空间就被释放掉了，但是空间本身还在，此时ret所引用的还是这一块空间，但是在第二次 Add 操作的时候，这块空间被重复利用了，空间内变量的值发生了改变，此时 ret 引用的值就变成了7了。

所以：将引用作为返回值时要注意空间释放的问题，要考虑这块空间是否还是原来的那块空间。

五、传值，传引用效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。

六、引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用一块空间。

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int& ra = a;

	cout << "&a = " << &a << endl;
	cout << "&ra = " << &ra << endl;
	return 0;
}

输出结果为：

但在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

#include<iostream>
using namespace std;
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中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8.访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全