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

阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6

引用

一、引用的概念

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

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

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. 引用比指针使用起来相对更安全
阿里云国内75折 回扣 微信号：monov8
阿里云国际，腾讯云国际，低至75折。AWS 93折 免费开户实名账号 代冲值 优惠多多 微信号：monov8 飞机：@monov6
标签: c++
返回列表

上一篇：C++11 auto关键字的用法

下一篇：基础IO（下）

“【C++】C++入门 引用详解 带你由浅入深理解引用” 的相关文章

C/C++编程题之简单错误记录1年前 (2023-02-02)
C/C++编程题之购物清单1年前 (2023-02-02)
C++ 基础语法21年前 (2023-02-02)
2023/1 寒假期间自学c++计划安排1年前 (2023-02-02)
【C++】string类的模拟实现1年前 (2023-02-02)
【C++】非递归实现二叉树的前中后序遍历1年前 (2023-02-02)
C++学习笔记——类和对象1年前 (2023-02-02)
【C++】为什么C++会支持函数重载1年前 (2023-02-02)
c++ - 第25节 - STL之空间配置器1年前 (2023-02-02)
VsCode简单使用，配置c/c++编译环境，个人感受1年前 (2023-02-02)

阿里云国际版