【C++】C++入门 引用详解 带你由浅入深理解引用

---

一、引用的概念

引用是给已存在变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间,对引用对象的操作与对变量直接操作完全一样。

其定义格式为：类型 &引用变量名 = 已定义过的变量名。
例如

int a = 10;
int& b = a; //给a起一个别名叫 b,对 b 进行任何操作都和直接对a的操作是一样的 

实例代码

#include<iostream>
using namespace std;
int main()
{
    
    
	int a = 10;
	int& b = a;
	a++;
	printf("a=%d\n", a);
	printf("b=%d\n", b);
	printf("a=%p\n", &a);
	printf("b=%p\n", &b);
	return 0;
}

二、引用的特点

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

#include<iostream>
using namespace std;
void Test1()
{
    
    
	int a = 10;
	int b = 20;
	// int& ra; // 引用未初始化，该条语句编译时会出错
	int& ra = a;
	//int& ra = b; //该条语句编译时会出错	C2374 “ra” : 重定义；多次初始化	
	int& rra = a;
	int& rrra = rra; //给别名取别名

	int* pa = &a;
	int*& rpa = pa;//给指针取别名

	cout << &a << endl;
	cout << &ra << endl;
	cout << &rra << endl;
	cout << &rrra << endl;

	cout << endl;

	cout << pa << endl;
	cout << rpa << endl;
}
int main()
{
    
    
	Test1();
	return 0;
}

三、特殊的引用——常引用

对于常引用理解的核心在于：指针和引用时权限只能缩小或保持,但不能放大

1.变量的常引用

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

	//引用时：
	//int& ra = a;  //报错  a不能被修改，故ra也不能被修改，属于权限放大
	const int& ra = a; //正常 a不能被修改，ra也不能被修改，属于权限保持

	//指针时：
	//int* pa = &a; //报错  a不能被修改，故pa也不能通过指针修改a，属于权限放大
	const int* pa1 = &a; //正常 a不能被修改，pa1也不能通过指针修改a，属于权限保持
	const int* const pa2 = &a; //正常 a不能被修改，pa2也不能通过指针修改a，且pa2不能指向其他地址，属于权限缩小

	int b = 20;
	int& rb = b; //正常 b与rb权限一致，属于权限保持
	const int& rrb = b; //正常 但是rb不能被修改，属于权限缩小

	int* ptr = NULL;
	int*& rptr1 = ptr; //正常 ptr与rptr1权限一致，属于权限保持
    int*& const rptr2 = ptr; //正常 但是rptr2不能改变指向，属于权限缩小
	return 0;
}

2.常数的常引用

注意：临时变量具有常性，函数的返回值以及强制类型转换的过程中都会产生临时变量，因此也具有常性

#include<iostream>
using namespace std;
int Count()
{
    
    
	static int n = 0;
	n++;
	return n;
}
int main()
{
    
    
	const int& a = 10;//正常，10是常数，属于权限保持。
	const int& b = Count(); //不加const会报错,临时变量具有常性！
	
	int c = 10;
	const double& d = c;//不加const会报错,d是c强制类型转化为double类型的过程中，double类型临时变量的引用
}

四、引用的使用场景

1. 作函数的参数

#include<iostream>
using namespace std;
void Swap(int& left, int& right)
{
    
    
	int temp = left;
	left = right;
	right = temp;
}
int main()
{
    
    
	int a = 10;
	int b = 20;
	Swap(a, b);
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;
	return 0;
}

引用传参如果形参为引用类型，则形参是实参的别名,所以修改时相当于直接在实参的基础上修改变量的值。

2. 做函数的返回值

要搞清楚引用做函数的返回值，我们的先对函数返回的过程有比较清晰的认识。

先看这样一段代码

#include<iostream>
using namespace std;
int Count()
{
    
    
	int n = 0;
	n++;
	return n;
}
int main()
{
    
    
	int ret = Count();
	return 0;
}

在实际执行代码时，会先创建main()函数的栈帧，在执行第一句代码时发现进行了函数调用，然后再创建Count()函数的栈帧，进入Count()函数内部执行代码。

代码执行完毕后，就会销毁Count()函数的栈帧，然后返回到main()函数的栈帧中，但是呢，变量 n 在Count()函数的栈帧销毁时，n也会销毁，这样就没有办法将 n 传递给 main()函数中的 ret 了，于是就需要有一个临时变量来保存返回值 n 的值。

等Count()函数的栈帧销毁完了，返回到main()函数的栈帧里了，临时变量再把 n 的值拷贝给 ret ,这就是函数返回的过程。

这里的临时变量分为两种

• 当返回值是一个占用空间较小的变量，通常会用寄存器做临时变量
• 当返回值是一个占用空间较大的一个结构体变量时，通常会在调用Count（）函数的那个函数的栈帧中提前开辟。

可能你会想函数之所以会这样返回是因为变量 n 是一个局部变量，局部变量离开作用域之后就没有办法存在了，如果把 n 变为全局变量会不会就不需要临时变量了呢？

答案是函数返回时依然会创建临时变量，因为编译器在做函数返回这件事情上是“傻瓜式的”，那这样岂不是有些亏吗？有没有办法去解决这个问题呢？答案是有的：就是引用做函数的返回值。

由于引用变量与原始变量在同一内存空间中，我们返回引用变量就相当于直接返回我们函数的返回值了，这样就可以消除临时变量了。但是使用引用返回一定要注意返回值必须离开该函数后还存在,否则就是非法访问了

代码实例1

//1.用引用做函数的返回值，可以减少返回值的拷贝
#include<iostream>
using namespace std;
int& Count()        //使用引用返回
{
    
    
	static int n = 0;//将 n 的生命周期延长 防止非法访问
	n++;
	return n;
}
int main()
{
    
    
	int ret = Count();
	cout << ret << endl;
	return 0;
}

由于我们使用引用做返回值，返回值是一个变量的别名，那么我们对这个别名是可以操作的，也就是说我们可以修改返回值
代码实例2

//2.使用引用返回，调用者可以修改返回对象的值
#include<iostream>
using namespace std;
int n = 10;//定义全局变量 n

int& Count()
{
    
    
	n++;
	return n;
}
int main()
{
    
    
	Count()=100; //如果Count()的返回值不是引用类型，则会报错 E0137	表达式必须是可修改的左值	
	cout << n << endl;
	return 0;
}

可以看出引用做函数的返回值有两个优点与一个注意点：

1. 用引用做函数的返回值，可以减少返回值的拷贝
2. 使用引用返回，调用者可以修改返回对象的值
3. 注意点：使用引用返回，则返回对象必须是静态的或全局的，或上一层栈帧的，或堆上申请的空间的。

通过上面的讲解相信你以及对引用做返回值有了不错的理解，那么让我们看看下面的一段代码,下面代码输出什么结果？为什么？

#include<iostream>
using namespace std;
int& Add(int a, int b)
{
    
    
	int n = a + b;
	return n;
}
int main()
{
    
    
	int& ret = Add(1, 2);
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

---

答案是：这个结果是随机的，并且代码是有bug，具体结果是未定义的，如果你答对了说明你学的非常好，如果答错了，就听我慢慢讲吧。


这个其实就是非法访问的问题，在实际执行代码时，会先创建main()函数的栈帧，在执行第一句代码时发现进行了函数调用，然后再创建Count()函数的栈帧，进入Count()函数内部执行代码。

代码执行完毕后，就会销毁Count()函数的栈帧，然后返回到main()函数的栈帧中，但是呢，变量 n 在Count()函数的栈帧销毁时，n也会销毁，n 这块空间被操作系统回收后，操作系统可能清理空间中的值也可能不清理，也就是 n 的空间中可能是 3 也可能是随即值。

又由于我们是引用做返回值，所以 ret 又是 n 原本空间的别名，对ret 进行访问也就相当于对已经销毁的 n 进行访问（此时已经是非法访问了），然而 n 的空间中可能是 3 也可能是随即值 ,所以输出结果是不确定的。

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

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

1.传参时传值、传引用效率比较

#include<iostream>
#include <time.h>
using namespace std;
#define N 10000
typedef struct A {
    
     
	int a[N]; 
}A;
void TestFunc1(A a) //传值
{
    
    
}
void TestFunc2(A& a) //传引用
{
    
    
}
void TestRefAndValue()
{
    
    
	A a;
	for (int i = 0; i < N; i++)
	{
    
    
		a.a[i] = i;
	}
	// 以值作为函数参数
	long begin1 = clock();
	for (long i = 0; i < 10000; ++i) 
	{
    
    
		TestFunc1(a);
	}
	long end1 = clock();

	// 以引用作为函数参数
	long begin2 = clock();
	for (long i = 0; i < 10000; ++i)
	{
    
    
		TestFunc2(a);
	}
	long end2 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
    
    
	TestRefAndValue();
	return 0;
}

大概有九倍多，当然你的可能与我不同，不过都应该是传引用更快！

2.返回时传值、传引用效率比较

#include<iostream>
#include <time.h>
using namespace std;
#define N 10000
typedef struct A {
    
    
	int a[N];
}A;
A a;

A TestFunc1(A a)
{
    
    
	return a;
}
A& TestFunc2(A a)
{
    
    
	return a;
}
void TestRefAndValue()
{
    
    
	for (int i = 0; i < N; i++)
	{
    
    
		a.a[i] = i;
	}
	// 以值作为函数参数
	long begin1 = clock();
	for (long i = 0; i < 10000; ++i)
	{
    
    
		TestFunc1(a);
	}
	long end1 = clock();

	// 以引用作为函数参数
	long begin2 = clock();
	for (long i = 0; i < 10000; ++i)
	{
    
    
		TestFunc2(a);
	}
	long end2 = clock();

	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
    
    
	TestRefAndValue();
	return 0;
}

大概有3倍，当然你的可能与我不同，不过都应该是引用返回更快！

六、浅析引用的底层原理

在浅析引用的底层原理之前，我们还是强调在C++语法方面我们还是认为引用是不开空间的！！ 在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

有了这样的公识，我们来看这样一段代码

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

	int* pa = &a;
	*pa = 30;
	return 0;
}

代码很简单我们再看看其汇编代码

每两条C++代码之间夹着的是：上一条C++代码的汇编实现，也是这条C++语句的底层原理。

①0Ah (h代表16进制，故0Ah是10) 这条汇编意味着给a赋值为10。
mov 是移动
dword 双字 (x32就是四个字节,x64就是八个字节）
ptr pointer缩写 即指针
[] 里的数据是一个地址值，

②lea 是取地址， rax是寄存器，这条汇编意味着将a的地址赋值给rax

③qword 双字 (x32就是四个字节,x64就是八个字节），这句话就是把rax的值给ra

rax里面放的是a的地址，rax能赋值给ra,说明ra是指针，
而ra在C++中又是引用，说明引用是用指针实现的，其大小为一个指针大小。也就是说引用其实开辟了新的空间。
但是我们还是在语法意义上认为引用不开空间，和其引用实体共用同一块空间。

④⑤这两条汇编也就是说，先将ra赋值给rax,再让14h(20)赋值给rax里面地址所指向的空间。

⑥⑦⑧⑨这是对指针的操作，对比②③④⑤对引用的操作，你会发现它们其实是一样的。

总之，引用的底层实现是指针，引用其实要开辟新的空间，但是我们一般从C++语法角度说引用不开空间。

七、总结

引用和指针的不同点:

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须初始化，指针没有要求
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何
   一个同类型实体
4. 没有NULL引用，但有NULL指针
5. 在sizeof中含义不同： 引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
7. 有多级指针，但是没有多级引用
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
9. 引用比指针使用起来相对更安全