C++学习系列（2）——引用&详细解释和底层源码剖析

前言

这是C++学习系列的第二篇文章，写的非常详细，深入的讲解了关于引用‘&’的详细解释和底层源码剖析，此外还有引用的用法以及与指针进行比较。相信你看完这篇博客一定对引用有了深刻的认识，希望我的博客可以给你带来帮助。最后本人能力有限，文章有问题欢迎指出！

一、引用概念

引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
类型& 引用变量名（对象名）= 实体名;

int main()
{
	int a = 10;
	int& ra = a; //定义引用类型
	printf("%p\n", &a);
	printf("%p\n", &ra);
	return 0;
}

我们可以发现变量a和ra的地址都是一样的，这也进一步的证实了其实引用就是给同一块内存空间起不一样的别名。
注意：引用类型必须和引用实体是同种类型的；

二、引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用被初始化后，不能再指向其他对象

void TestRef()
{
	int a = 10;
	// int& ra;   // 该条语句编译时会出错
	int& ra = a;
	int& rra = a;
	printf("%p\n%p\n%p\n", &a, &ra, &rra);
}

我们可以发现三个变量的地址都是一样的。
可能看到这里有的朋友会觉得疑问，什么叫做“引用被初始化后，不能再指向其他对象？”下面我将给出详细的解释：

int a = 7;
int& b = a;
cout << b << ' ' << &b << endl;
int x = 8;
b = x;
cout << b << ' ' << &b << endl;

运行结果：

我们看到 ‘ b = x ’ 此时b的地址还是变量a的地址，这里b的地址映射还是0000000AA16FFA54，这里b作为左值仅仅是改变地址里存的内容，若用"&b"这种符号作为左值，编译器会报错，提示“左边必须是可修改的值"，看到了吧，“引用被初始化后，不能再指向其他对象”这种话的意思体现了吧，也就是说b变量作为a的别名，已经映射了地址0000000AA16FFA54，它不能再映射其它地址，也就是说它不能再作为其它对象的别名了。

三、常引用

在C++中规定不允许常量引用，即给常量起别名
“常量引用”其实是对“const的引用”的简称，并且“常量引用”不能被用作修改它所绑定的对象。

1. 指向常量对象时，一定要使用“常量引用”，而不能是一般的引用。因为不允许直接为常量赋值，当然也就不能通过引用去改变常量。因此直接规定当引用一个常量时，必须使用“常量引用”。

const int c = 23;
const int& rc = c; //正确，引用及其引用的对象都是常量
rc = 24; //错误，rc是常量的引用，不能被用作修改常量
int& a = c; //错误，试图用一个非常量引用指向一个常量引用

2. “常量引用”可以指向一个非常量对象，但不允许用该引用修改非常量对象的值。注意：常量引用仅对引用可参与的操作做了限定，对于引用的变量是不是一个常量未做限定。

	int i = 0;
	int& ri = i;//正确，普通引用指向非常量对象i
	const int& rc = i;//正确，常量引用可以指向非常量对象i
	ri = 2;//正确，ri是i别名，可以通过引用修改非常量对象的值
	rc = 2;//错误，rc是常量引用，对引用加以了限制，此时的rc虽然是i的别名，但是不能通过rc去修改非常量对象的值

3. 引用的类型必须和所引用的类型严格匹配，且不能与字面值或者某个表达式的计算结果绑定在一起，但是“常量引用”是例外（只要被转换的类型可以转换为常量引用的类型）

int i = 42;
const int& r1 = i;//正确
const int& r2 = 42;//正确
const int& r3 = i * 2;//正确
int& r4 = i * 2;//错误，因为非引用常量不能与表达式的结果绑定在一起

下面的操作也是允许的：

double val = 42.9;
const int& ri = val;
printf("%d",ri): //运行为5

在这里有个有趣的地方，下面我将这两个变量的地址打印出来：

double val = 42.9;
const int& ri = val;
printf("%p\n%p\n",&val,&ri);

运行结果：

我们发现，此时val和引用变量ri不是一个地址，说明此处在编译的时候做了一些变化，实际上相当于执行了下列语句：

const int temp = val;
const int& ri = temp;

引用和原val不是一个地址空间了，在这些情况下，“常量引用”实际上是绑定了一个临时量（temporary）对象。也就是说，允许“常量引用”指向一个临时量对象。

总结：也就是说，不允许一个普通引用与字面值或者某个表达式的计算结果，或类型不匹配的对象绑定在一起，其实就是不允许一个普通引用指向一个临时变量，只允许将“常量引用”指向临时对象。

四、使用场景

4.1做参数

我们以前学C语言的时候，编写一个交换函数，需要用到指针和解引用（因为函数中形参只是实参的拷贝，所以在传参的时候需要把地址给函数，用指针和解引用去操控地址里的数据），例如下面：

void swap(int* x,int* y)
{
	int temp = *x;
	*x = *y;
	*y = temp;
}

这样子写就会比较麻烦，很多时候会有同学忘记要解引用，但是C++中有了&就会方便很多：

void swap(int& x, int& y)
{
	int temp = x;
	x = y;
	y = temp;
}
int main()
{
	int x = 5, y = 6;
	printf("%d %d\n", x, y); // 5  6
	swap(x, y);
	printf("%d %d\n", x, y); // 6  5
}

因为引用是给变量取别名，所以函数参数里的（int& x, int& y)其实就是实参的别名，此时就不需要再解引用，可以直接在swap函数里进行交换，main函数中的原变量值x，y也会交换。

4.2做返回值

首先我们来探究下我们以前学习的函数传值返回和传引用返回的区别。下面我给出具体的区别，后面会进行讲解。
【传值返回和传引用返回的区别】
1. 减少拷贝
我们知道，在函数传值返回中，当函数执行完成后就会销毁，将空间归还给操作系统。因此此时我们返回的变量其实是函数中局部变量的临时拷贝。

例如，当Count函数执行完成后，函数栈帧就会销毁，所以此时在编译器中其实返回的变量n是一个临时拷贝（临时变量对局部变量n的拷贝）。

而在传引用返回中，其实返回的是局部变量n的别名（因为是引用返回），所以我们可以暂时理解为返回的其实就是这个局部变量本身，因此减少了拷贝，比传值返回效率更高。

2. 调用者可以修改返回对象
下面是传值返回和传引用返回，让我们探究下他们有什么区别😀

//传值返回
int Add(int x, int y)
{
	int c = x + y;
	printf("%p\n", &c);
	return c;
}
int main()
{
	int ret = Add(1, 2);
	printf("%p\n", &ret);
	return 0;
}

运行结果：

//传引用返回
int& Add(int x, int y)
{
	int c = x + y;
	printf("%p\n", &c);
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	printf("%p\n", &ret);
	return 0;
}

运行结果：

通过比较两个运行结果我们可以发现，在传值返回中，Add函数中返回变量c和main函数中接收变量ret地址不相等，而在传引用返回中两个变量地址相等。说明在传引用返回时Add函数返回了变量c的别名，main函数接收返回值变量的ret就指向了变量c，此时两个变量共用一块地址空间。
那么，是不是就代表着我们可以在函数外面修改返回对象呢🤔，那让我们来试试吧！

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	printf("Add(1,2) is: %d\n", ret);
	printf("Add(1,2) is: %d\n", ret);	
	return 0;
}

运行结果：

嗯？？？好奇怪，为什么两次运行结果不一样呢，第二次的值还这么奇怪🤔？其实这是由变量的属性所决定的，我们知道，当函数结束时就会将这块空间返还给操作系统，所以在传值返回的时候就会用一个临时变量存储在函数中返回的局部变量的值。但是在传引用返回时，我又说为了理解其实他相当于将自己传了回去，但这是错误❌的，因为函数已经销毁了啊，里面的局部变量应该跟着它一起返还给操作系统了才对，是不能再返回给我们的，所以传引用返回是有条件的，如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回那么只有静态变量，全局变量，堆上以及上一层栈帧的变量可以使用传引用返回😄。
解释完相信大家就明白了，因为我们用的是局部变量，变量是在栈上开辟的，所以在我们第一次调用的时候，他可能还没有被操作系统所修改，我们输出的是正确的值；但是当我们第二次再调用的时候，这块空间已经被操作系统所回收的，所以结果是随机值，当然，这也是非法访问，所以这个程序是错误❌的。
下面是有关于函数在程序运行结束后函数的局部变量如何销毁的形象图。

【总结】：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用
引用返回，如果已经还给系统了，则必须使用传值返回。
下面我来给大家写出正确的传引用返回的函数。

int& Add(int a, int b)
{
	static int c = 0; //这里是用static修饰，所以c是静态变量
	c = a+b;
	return c;
}
int main()
{
	int& ret = Add(1, 2);
	Add(3, 4);
	printf("Add(1,2) is: %d\n", ret);
	printf("Add(1,2) is: %d\n", ret);	
	return 0;
}

运行结果：

此时我们发现，两次运行的结果都是7啦，也就说明代码是正确的🤭
所以我在给大家总结一下：
传值返回和传引用返回的区别

1. 传引用返回比传值返回减少拷贝
2. 传引用返回调用者可以修改返回对象

哪些变量可以用传引用返回？

1. 静态变量
2. 全局变量
3. 堆上开辟空间的变量（malloc）
4. 在上一层栈帧的变量

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

5.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;
}

运行结果：

5.2 传值返回和传引用返回效率比较

#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()
{
	int a = 10;
	int& ra = a;
	cout<<"&a = "<<&a<<endl;
	cout<<"&ra = "<<&ra<<endl;
	return 0;
}

运行结果：

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

int main()
{
	//此时指针和引用都会改变变量a的值
	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. 引用比指针使用起来相对更安全（没有野指针等问题）。