【C++】初阶 --- 引用（超级详细版！！！）

C-调战士2023-08-03 22:41

文章目录

🍪一、引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。
比如：李逵，在家称为"铁牛"，江湖上人称"黑旋风"
比如：抓 "周树人" 和我 "鲁迅"有什么关系🤭，本质上其实是一个人

🚩引用的操作符： &
🚩类型& 引用变量名(对象名) = 引用实体

🌰举个栗子演示👇

c 复制代码 
int main()
{
	int a = 0;
	int& b = a; //引用

	cout << &a << endl;
	cout << &b << endl;

	return 0;
}

☝️代码段中相当于给变量a取了一个别名b，通过标识名b可以在其被定义的作用域中访问变量a，可以看到地址是一样的，说明a和b共用同一块内存空间

🚨注意：引用类型必须和引用实体是同种类型的

🍪二、引用的特性

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

🥰请看代码与注释👇

c 复制代码 
void TestRef()
{
	int a = 10;
	// int& ra;  // 该条语句编译时会出错
	int& ra = a;
	
	cout << a << "  " << &a << endl;
	cout << ra << "  " << &ra << endl;
}

int main()
{
	TestRef();

	return 0;
}

🚨int& ra; 该条语句编译时会出错，是不可以的，必须要进行初始化

🍿2、一个变量可以有多个引用

🚩一个变量可以有多个引用，并且引用可以嵌套定义

🥰请看代码与注释👇

c 复制代码 
void TestRef()
{
	int a = 10;
	// int& ra;  // 该条语句编译时会出错
	int& ra = a; // ra是a的引用
	int& rra = a; // rra是a的引用
	int& rrra = ra; // rrra是ra的引用
	
	cout << a << "  " << &a << endl;
	cout << ra << "  " << &ra << endl; 
	cout << rra << "  " << &rra << endl;
	cout << rrra << "  " << &rrra << endl;
}

int main()
{
	TestRef();

	return 0;
}

基于引用这种可以嵌套定义并且无需多次解引用就可以直接访问被引用变量的这种特性，很多时候使用引用可以避免多级指针的出现

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

🌰举个栗子演示👇

c 复制代码 
void TestRef()
{
	int a = 10;
	int b = 20;

	int& x = a; 
	int& x = b; 
	
	cout << a << "  " << &a << endl;
	cout << x << "  " << &x << endl; 
	cout << b << "  " << &b << endl;
	cout << x << "  " << &x << endl;
}

由于这个特性，引用无法完全代替指针(比如链表中结构体的next指针无法用引用来代替，因为引用一旦引用一个实体，再不能引用其他实体)，灵活性也不如指针，但是引用也因此比指针更安全，这也是引用这个语法的设计初衷之一(使用指针很容易出现野指针，非法访问内存空间的情况)

🍪三、常引用(被const 修饰的引用)

🚨在引用的过程中，权限可以平移，权限可以缩小，但是权限不能放大！

🍿1、权限的放大

假如a是鲁智深 可以喝酒 可以吃肉 不能杀人
给a取个别名b 叫花和尚 可以喝酒 可以吃肉 可以杀人？
a（鲁智深）和 b（花和尚）是同一个人，当然不可以杀人

🌰举个栗子👇

c 复制代码 
int main()
{
	//权限的放大
	const int a = 0;
	int& b = a;

	return 0;
}

🍿2、权限的平移

🌰举个栗子👇

c 复制代码 
int main()
{
	//权限的平移
	const int a = 0;
	const int& b = a;

	return 0;
}

🍿3、权限的缩小

🌰举个栗子👇

c 复制代码 
int main()
{
	//权限的缩小
	int a = 0; //a可以修改，可以影响b
	const int& b = a;

	return 0;
}

a可以修改，可以影响b

🍿4、临时变量具有常性

🌰举个栗子👇

c 复制代码 
int main()
{
	int i = 0;
	double& d = i;//临时变量具有常性

	return 0;
}

✅正确操作👇

c 复制代码 
int main()
{
	int i = 0;
	const double& d = i;

	return 0;
}

🚩这里涉及一个知识点：
代码段中b去引用i，i会发生隐式类型转换，i转换的结果会存入一个临时空间中。
(当赋值等号右边有运算表达式或有变量发生类型转换时，表达式或类型转换的结果都会先存入一个临时空间后再赋值给等号左边的变量)
因此这里的d引用的实质上是一块临时空间：

🍪四、引用的使用场景

🍿1、做参数（传引用传参）

🌰举个栗子👇

c 复制代码 
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、做返回值（引用做返回值）

先看一下传值返回👇

c 复制代码 
//传值返回    
int Count()
{
	int n = 0;
	n++;
	// ...
	return n;
}

int main()
{
	int ret = Count();
	cout << ret << endl;

	return 0;
}

我们非常的熟悉，结果为 1

再来看一下下面这段代码👇

c 复制代码 
//传引用返回
int& Count()
{
	int n = 0;
	n++;
	// ...
	return n;
}

int main()
{
	int ret = Count();
	//这里打印的结果可能是1，也可能是随机值
	cout << ret << endl;

	return 0;
}

🚨这里输出的结果有两种可能，一种为 1 ，另一种可能为随机值，原因是：传引用返回返回的是n的别名，但是这里存在的问题是我们返回n的别名也就是访问n这块空间，访问n这块空间就有两个结果：如果这个栈帧没有清除，它的值就是1，如果它的空间被清了，那么它的就会是一个 随机值

看图比较一下两段代码👇

上面的理解了之后，再看一段代码👇

c 复制代码 
int& Count()
{
	int n = 0;
	n++;
	// ...
	return n;
}

int main()
{
	int& ret = Count();
	//这里打印的结果可能是1，也可能是随机值
	cout << ret << endl;
	cout << ret << endl; //被覆盖

	return 0;
}

这是为什么呢？

🚨函数调用要先传参，也就是先取值，这个时候还没有建立栈帧，取值之前还没有被覆盖，传参过去之后，建立栈帧，值不会受到影响；那第二次调用，再去取值，这时这个值已经被建立的栈帧覆盖了，所以输出的是随机值

理解了之后，再看一段代码👇

c 复制代码 
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;
}


这样的函数不能使用引用返回，是非常不安全的，相当于野引用（野指针）的方式

🚨**注意：**如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回

🍿3、传值、传引用效率比较

🥗 传值和传引用的作为参数的性能比较

c 复制代码 
#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;
}

🥗 传值和传引用的作为返回值的性能比较

c 复制代码 
#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;
}

🍿4、传引用返回修改返回对象

传引用返回还有一个隐藏作用：

假如一个顺序表要进行读和修改数据

c 复制代码 
struct SeqList
{
	int* a;
	int size;
	int capacity;
};

🚩C的接口设计：

c 复制代码 
//C的接口设计

//读取第i个位置的值
int SLAT(struct SeqList* ps, int i)
{
	assert(i < ps->size);
	//...
	return ps->a[i];
}
//修改第i个位置的值
void SLModify(struct SeqList* ps, int i, int x)
{
	assert(i < ps->size);

	//...
	ps->a[i] = x;
}

🚩CPP的接口设计：

c 复制代码 
//CPP的接口设计

//读 or 修改第i个位置的值
int& SLAT(struct SeqList& ps, int i)
{
	assert(i < ps.size);
	//...
	return ps.a[i];
}

int main()
{
	struct SeqList s;
	//...
	SLAT(s, 0) = 10;//修改
	SLAT(s, 1) = 20;
	SLAT(s, 2) = 30;
	cout << SLAT(s, 0) << endl;//打印
	cout << SLAT(s, 1) << endl;
	cout << SLAT(s, 2) << endl;

	return 0;
}

这里相比 C的接口设计来看，非常的香，减少了拷贝🥰

🍿5、总结

🚩传引用传参（任何时候都可以）

1、提高效率
2、输出型参数（形参的修改，影响实参）

🚩传引用返回（出了函数作用域对象还在才可以用）

1、提高效率
2、修改返回对象

🍪五、引用和指针的区别

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

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

c 复制代码 
int main()
{
	int a = 0;
	int* p1 = &a;
	int& ref = a;
	
	return 0;
}

我们来看下引用和指针的汇编代码对比：

🥰可以看到：引用和指针底层是一样的，可以说是引用就是化了妆的指针

引用和指针的不同点：

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

😍这期内容有一点难理解，希望烙铁们能理解消化，有所收获哦！

总结🥰
以上就是 【C++】引用 的全部内容啦🥳🥳🥳🥳
本文章所在【C++初阶】专栏，感兴趣的烙铁可以订阅本专栏哦🥳🥳🥳
前途很远，也很暗，但是不要怕，不怕的人面前才有路。💕💕💕
小的会继续学习，继续努力带来更好的作品😊😊😊
创作写文不易，还多请各位大佬uu们多多支持哦🥰🥰🥰

相关推荐
懒大王爱吃狼29 分钟前
Python教程：python枚举类定义和使用
开发语言·前端·javascript·python·python基础·python编程·python书籍
秃头佛爷2 小时前
Python学习大纲总结及注意事项
开发语言·python·学习
待磨的钝刨2 小时前
【格式化查看JSON文件】coco的json文件内容都在一行如何按照json格式查看
开发语言·javascript·json
XiaoLeisj3 小时前
【JavaEE初阶 — 多线程】单例模式 ＆ 指令重排序问题
java·开发语言·java-ee
励志成为嵌入式工程师4 小时前
c语言简单编程练习9
c语言·开发语言·算法·vim
捕鲸叉5 小时前
创建线程时传递参数给线程
开发语言·c++·算法
A charmer5 小时前
【C++】vector 类深度解析：探索动态数组的奥秘
开发语言·c++·算法
Peter_chq5 小时前
【操作系统】基于环形队列的生产消费模型
linux·c语言·开发语言·c++·后端
wheeldown6 小时前
【数据结构】选择排序
数据结构·算法·排序算法
记录成长java6 小时前
ServletContext,Cookie,HttpSession的使用
java·开发语言·servlet
热门推荐
01【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总02(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明03组基轨迹建模 GBTM的介绍与实现（Stata 或 R）04【AIGC】重塑未来的科技巨轮05全面解析：构建基于深度学习的安全帽检测系统（UI界面+YOLO代码+数据集）06【经验分享】Ubuntu22.04安装微信(linux官方版)07基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测08Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO09RAG 实践- Ollama+RagFlow 部署本地知识库10红米手机使用google play