3. C++入门：引用

引用

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

int main()
{
	int a = 1;
	int b = a;

	int& c = a;
}

创建一个a变量，把1赋值给a
新创建一个b变量，把a的值拷贝给b
把原来a所指的空间，又取了个名字叫c，本质是可以理解为取别名

b++，a不会有影响
c–，就是对a–，因为a就是c，c就是a

类型& 引用变量名(对象名) = 引用实体；
引用类型必须和引用实体是同种类型的

引用特性

引用在定义时必须初始化
一个变量可以有多个引用，也可以给别名取别名
引用一旦引用一个实体，再不能引用其他实体

int& d = a;
int& e = c;

a，c，d，e的地址是一样的

常引用

int main()
{
	const int a = 10;
	//1  
	int& b = a;
	//2
	const int& b = a;	
	
	int c = 20;
	//3
	const int& d = c;

	//4
	const int& e = 10;

	//5
	int b = a;

	return 0;
}

a自己不能修改，别名也不能修改
语句1是错误的，出现权限的放大
语句2是正确的，得平移权限
语句3是正确的，权限可以缩小
语句4是正确的，e可以变成10的别名。不能不加const，权限会放大
语句5是正确的，这里是把a的值拷贝给b，b的修改不会影响a
指针也是类似的

const别名的意义

如果不是为了修改变量，加上const，既可以作const变量的别名，也可以作非const变量的别名

int main()
{
	int i = 1;
	//6
	double& rj = i;
	//7
	const double& sj = i;

	return 0;
}

语句6是错误的，语句7是正确的
类型转换，不管是隐式类型转换还是强制类型转换中间都会产生一个临时变量
也就是i先传给临时变量，临时变量再传给rj
rj引用的不是i，而是这个临时变量。而临时变量具有常性
所以语句6是权限的放大，加上const就可以了

类型转换会产生临时变量

隐式类型转换，类型截断，类型提升

int x = 0;
size_t y = 1;
if (x > y)
{

}

不同类型的对象在进行运算的时候会进行类型的提升
有符号和无符号比，有符号就会被提升为无符号
比较的时候，x会进行类型提升，并不是把x变成无符号，是生成了一个临时变量，把临时变量看成是无符号的，然后去和y比

int* ptr = (int*)i;

把i强制类型转换成指针
i的类型不会变，而是新建了一个临时变量，变成了指针

int ii = 10000;
char ch = ii;

属于类型截断，不是把ii截断，而是把生成的临时变量截断

引用的使用场景

1. 作参数

形参是实参的别名，形参改变实参
提高效率

Swap

void Swap(int* left, int* right)
{
	int temp = *left;
	*left = *right;
	*right = temp;
}

int main()
{
	int a = 0, b = 2;
	Swap(&a, &b);

	return 0；
}

C语言要交换两个变量不能直接传参数，这样不能完成交换
left是a的拷贝，right是b的拷贝，left和right的改变，不影响a和b
所以必须把a和b的地址传过去，Swap里解引用，改变a和b

void Swap(int* left, int* right)
{
	int temp = *left;
	*left = *right;
	*right = temp;
}

void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = temp;
}

int main()
{
	int a = 0, b = 2;
	Swap(&a, &b);
	Swap(a, b);

	return 0；
}

C++中有引用，可以这样写代码
C++还可以构成函数重载，两个同名函数，参数一个是指针，一个是引用

SListNode

typedef struct SListNode
{
	struct SListNode* next;
	int val;
}SLTNode;

void SListPushBack(SLTNode* phead, int x)
{
	if (phead == NULL)
	{
		//...
		//phead = newnode;
	}
	else
	{
		//找尾结点，再链接newnode
		//tail->next = newnode;
	}
}

int main()
{
	SLTNode* plist = NULL;
	SListPushBack(plist, 1);
	SListPushBack(plist, 2);
	SListPushBack(plist, 3);

	return 0;
}

这段代码是有问题的
这里phead是plist的拷贝
函数里phead的改变不能改变外面的plist
比如要改变int，只能传int*，int*解引用才是int
这里plist是Node指针，要改变Node*，要传Node**
要这样写：

typedef struct SListNode
{
	struct SListNode* next;
	int val;
}SLTNode;

void SListPushBack(SLTNode** pphead, int x)
{
	if (*pphead == NULL)
	{
		//...
		//*pphead = newnode;
	}
	else
	{
		//找尾结点，再链接newnode
		//tail->next = newnode;
	}
}

int main()
{
	SLTNode* plist = NULL;
	SListPushBack(&plist, 1);
	SListPushBack(&plist, 2);
	SListPushBack(&plist, 3);

	return 0;
}

在C++里可以使用引用

typedef struct SListNode
{
	struct SListNode* next;
	int val;
}SLTNode, *PSLTNode;

void SListPushBack(PSLTNode& phead, int x)
{
	if (phead == NULL)
	{
		//...
		//phead = newnode;
	}
	else
	{
		//找尾结点，再链接newnode
		//tail->next = newnode;
	}
}

int main()
{
	PSLTNode plist = NULL;
	SListPushBack(plist, 1);
	SListPushBack(plist, 2);
	SListPushBack(plist, 3);

	return 0;
}

SLTNode是节点的typedef，*PLSTNode是节点指针的typedef
在这里phead是plist的别名

2. 作返回值

引用返回错误使用

传值返回

int Count(int n = 0)
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int ret = Count;
	
	return 0;
}

Count函数会创建一个变量是n，局部变量会存在栈帧里面
调用完函数以后，不能用n作为函数Count的返回值，因为函数调用完成后，函数栈帧就销毁了。n是属于Count的函数栈帧，n就也跟着销毁了
去访问n，就形成了野指针
Count函数返回的是n的拷贝，传值返回
如果对象比较小，n的拷贝是存在寄存器里面的
如果对象比较大，n的拷贝会存在Count栈帧销毁不影响的那块空间

这个n的拷贝，作为Count的返回值，再拷贝给ret
所以这里只能用传值返回

函数引用返回给ret

如果使用引用返回

int& Count(int n = 0)
{
	int n = 0;
	n++;

	return n;
}

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

	cout << ret << endl;
	
	return 0;
}

传引用返回
引用返回就是返回n的别名，其实就是n，然后赋值给ret
结果是不确定的
取决于函数栈结束的时候，会不会把这块空间给清理了
如果清理了，这个数就是随机值
如果没有被清理，这个值就是1

这时候打印两次ret，两次都是1
因为函数调用完之后，ret是在main函数栈帧里的，所以不管下面的栈帧如何变，都不会影响到ret

ret是函数返回值的引用

两次打印

int& Count(int n = 0)
{
	int n = 0;
	n++;

	return n;
}

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

	cout << ret << endl;
	
	return 0;
}

但是如果ret是函数返回值的引用
第二次打印就会变成随机值
2. 再次调用，加第三次打印

int& Count(int n = 0)
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int& ret = Count();
	cout << ret << endl;
	cout << ret << endl;
	Count();
	cout << ret << endl;
	
	return 0;
}

第三次打印又变成1
3. 带参数打印

int& Count(int n)
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int& ret = Count(1);
	cout << ret << endl;
	cout << ret << endl;
	Count(10);
	cout << ret << endl;
	
	return 0;
}

带参数的话，三次打印都是随机值
所以结果是随机的，程序是错误的，不能用引用去返回，会出各种坑

引用返回错误样例

int& Add(int a, int b)  
{  
	int c = a + b;  
	return c;  
}  
int main()  
{  
	int& ret = Add(1, 2); 
	cout << "Add(1, 2) is :"<< ret <<endl;   
	Add(3, 4);  
	cout << "Add(1, 2) is :"<< ret <<endl;  
	
	return 0;
}

第一次打印的结果是3或者是随机值，取决于是否清理栈帧
第二次打印的结果是7
第二次没有赋值给ret，因为函数结束没有清理函数栈帧
![[Pasted image 20240514164456.png]]

c的别名赋值给ret，ret没有空间，因为ret本质也是c的别名
ret其实相当于野指针，引用的空间已经销毁了
cout访问ret，也就是访问c
第一次打印是3，之后函数栈帧销毁
之后第二次调用Add函数
空间是可以重复利用的，因为是同一个函数，所以第二次调用和第一次调用用的是同一块空间。c所处的位置就被修改成7，ret始终没变，是这块空间的别名，所以ret第二次打印就变成了7，也有可能是随机值
出了函数作用域，返回对象就销毁了，不能用引用返回，否则结果是不确定的

栈帧空间是可以重复利用的

void func()
{
	int c = 0;
	cout << &c << endl;
}
int main()
{
	func();
	func();
	return 0;
}

两次打印的地址是一样的

void func1()
{
	int c = 0;
	cout << &c << endl;
}
void func2()
{
	int a = 0;
	cout << &a << endl;
}
int main()
{
	func1();
	func2();
	return 0;
}

这样结果也是一样的，a和c是同一块空间

引用返回正确使用

什么情况下可以用引用返回
是静态变量就可以了，malloc也可以
只要不在函数作用域内，没销毁就可以
出了函数作用域，这个对象还在，才能用引用返回

int& Add(int a, int b)  
{  
	static int c = a + b;  
	return c;  
}  
int main()  
{  
	int& ret = Add(1, 2); 
	cout << "Add(1, 2) is :"<< ret <<endl;   
	Add(3, 4);  
	cout << "Add(1, 2) is :"<< ret <<endl;  
	
	return 0;
}

因为c是静态变量，所以c不在Add的栈帧里面，在静态区里面
Add销毁就不影响c了
结果就是3和3

ret是c的别名，访问ret就是访问c
局部的静态变量只会被初始化一次
在第一次调用的时候，初始化了，第二次调用的时候，就不走初始化了

int& Add(int a, int b)  
{  
	static int c;
	c = a + b;  
	return c;  
}  
int main()  
{  
	int& ret = Add(1, 2); 
	cout << "Add(1, 2) is :"<< ret <<endl;   
	Add(3, 4);  
	cout << "Add(1, 2) is :"<< ret <<endl;  
	
	return 0;
}

这样是3和7
因为这样写，c = a + b每次都会走，c就变成7了

效率比较

传值传引用效率比较

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

#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;
}

值和引用的作为返回值类型的性能比较

#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;
}

可以修改返回对象

#include <iostream>
#include <assert.h>

typedef struct SeList
{
	int a[100];
	int size;
}SL;

void SLModify(SL* ps, int pos, int x)
{
	//...
	assert(ps);
	assert(pos < ps->size);
	ps->a[pos] = x;
}

int& SLat(SL* ps, int pos)
{
	assert(ps);
	assert(pos < ps->size);
	
	return ps->a[pos];
}

int main()
{
	SL s;
	//每个位置的值++
	for (size_t i = 0; i < s.size; i++)
	{
		SLat(&s, i)++;
	}
	SLModify(ps)

	return 0;
}

SLat函数引用返回的是顺序表里面pos位置的字符的别名
进行修改赋值就很方便

引用和指针的区别

引用不能替代指针

引用必须初始化，必须有一个引用的实体

int main()
{
	int a = 0;
	//int& b; 错误

	return 0；
}

引用不能改变指向

int main()
{
	int a = 0;

	int& c = a;
	int d = 1;

	c = d;

	return 0;
}

这里不是c变成d的别名，而是d赋值给c

一个对象可以有多个别名，可以给别名取别名

所以C++引用不能替代指针

链表中，要让上一个节点找到下一个节点
这里java可以使用引用，因为java引用的指向是可以改变的
C++的引用不能改变指向，所以引用不能替代指针
引用和指针可以配合着使用

引用底层是用汇编实现的

int main()
{
	int a = 10;

	//语法上，b没有开空间
	int& b = a;

	//语法上，ptr开了空间
	int* ptr = &a;

	return 0;
}

底层上，引用和指针是一样的
![[Pasted image 20240514224859.png]]

lea是取地址，把a的地址放到rax
mov是移动，把rax的值放到b的变量里
语法上和底层是不一致的
在底层没有引用，都是指针

日常学习使用的时候，以语法为主，认为引用没有开空间。
指针开了空间，存地址

char ch = 'x';
char& r = ch;
cout << sizeof(r) << endl;

结果是1
引用算的是引用的对象的大小
算r就是算的ch
底层开了4个空间，因为要用指针实现

引用和变量的不同点

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