【C++】浅析C++引用

引用的概念

引用相当于给一个已存在的变量取了一个别名。
引用的符号是&，与取地址和按位与的符号是一样的。

int a = 10;
int& b = 10;

上面的代码表示b是a的引用，如果我们对a和b取地址就会发现它们的地址是一样的，说明它们表示的是同一块空间。相当于一个人名字叫做a，但别人给他起了一个外号叫b，不管叫a还是叫b，都是叫的这一个人。

int c = a;

而这里的c相当于新开辟了一块空间，把a的值给拷贝进去了。

引用的特性

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

int a = 10;
int& b;

在这里引用b并没有指定对象，比如你想给你舍友取名叫“儿子”，但你并没有指定某个对象作为你“儿子”，在你使用“儿子”这个称呼时，别人不知道你找的谁，也就没人理你了

2. 一个变量可以有多个引用
   也就是说一个变量可以有多个别名，你村李二牛，你可以叫他牛哥，又可以叫他阿牛

int a = 10;
int& b = a;
int& c = a;
int& d = c; //...类似这样还能取更多的名字

3. 引用一旦引用一个实体，便不能再引用其他实体
   你已经给李二牛取了别名叫阿牛，那就不能再给李狗蛋也取个名叫阿牛，那样就不知道你要找的是谁了

int a = 10;
int x =20;
int& b = a;
int& b = x;//这样是不行的，因为b已经引用了a,再去引用x会产生混淆，产生命名冲突

但是指针却可以改变指向

int a = 10;
int b = 20;
int* p = &a;
p = &b;//指针p的指向从a指向了b

指针在链表中能够找到下一个结点，但引用就不行，所以引用实现不了链表

引用的使用

光给变量另取一个名字是没有什么意义的，引用的作用在于做参数和做返回值

引用做参数

我们学C的时候学过指针，我们知道，函数传参有两种方式：传值和传地址。传值时形参是实参的拷贝，传地址时形参是实参的指针。想要通过函数想要改变实参的内容，就要把实参的地址传给形参。因为形参是在栈帧开辟出来的另一块空间，修改形参对实参的原始空间并没有改动，所以要传实参的地址，通过指针解引用来找到实参的空间内容进行改动。

用一个交换值的函数示例

void sawp(int a, int b)//传值
{
	int tmp = a;
	a = b;
	b = tmp;
}

void swap(int* a, int* b)传地址
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

void swap(int& a, int& b)//传引用
{
	int tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int x = 1;
	int y = 2;
	swap(&x, &y);//指针的用法
	swap(x, y);//引用的用法
	return 0;
}
//以上三个swap函数可以构成函数重载，但在调用时，swap（x,y）会产生歧义，不知道是传值还是传引用。类似无参和全缺省的情况

交换x和y的值，相当于改变了x和y的内容。引用的用法与指针用法不同的是：参数是用的引用，传参时只传变量名，不用传地址。上面我们说引用在定义时必须初始化，这里相当于引用接收参数时完成初始化。
单向链表中的指针传参

typedef int SLDataType;

typedef struct SListNode
{
	SLDataType data;
	SLTNode* next;
}SLTNode,*PSLTNode;

SLTNode* Buynode(SLDataType x)//新建结点
{
	SLTNode* newnode = (SLTNode*)malloc(sizeof(SLTNode));
	newnode->data = x;         
	newnode->next = NULL;
	return newnode;
}
//链表尾插
void SLTPushBack(SLTNode** pplist,SLDataType x)//指针的指向发生改变，所以传参时要把头结点指针的地址传进来，用二级指针接收;
{
	SLTNode* newnode = Buynode(x);
	if (*pplist == NULL)
	{
		*pplist = newnode;
	}
	else
	{
		SLTNode* tail = *pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}

int main()
{
	SLTNode* plist = NULL;
	SLTPushBack(&plist, 1);
	SLTPushBack(&plist, 2);
	SLTPushBack(&plist, 3);
	SLTPushBack(&plist, 4);
	return 0;
}

在上面代码定义的链表结构体中，SLTNode表示给结构体struct
SListNode用typedef起来一个名字，SLTNode等同于struct SListNode；PSLTNode表示一个struct
SListNode类型的指针,等同于SLTNode；所以在类似链表这种传参方式中用引用传参可写作

void SLTPushBack(SLTNode*& pplist,SLDataType x)
{        //或者是 PSLTNode& pplist
	SLTNode* newnode = Buynode(x);
	if (pplist == NULL)
	{
		pplist = newnode;
	}
	else
	{
		SLTNode* tail = pplist;
		while (tail->next != NULL)
		{
			tail = tail->next;
		}
		tail->next = newnode;
	}
}
int main()
{
	SLTNode* plist = NULL;
	SLTPushBack(plist, 1);
	SLTPushBack(plist, 2);
	SLTPushBack(plist, 3);
	SLTPushBack(plist, 4);
	return 0;
}

引用做返回值

在学引用做返回值之前，我们要先了解一下传值返回的机制

int Add(int a,int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int ret = Add(1,2);
	cout<<ret<<endl;
	return 0;
}

main函数里调用了Add函数，Add通过返回值把结果返回给ret,但Add并不是把c返回，而是通过一个临时变量保存c的值，再把临时变量返回因为c是保存在Add的函数栈帧中的，函数调用完函数栈帧就会销毁，空间已经还给了操作系统，这时候再去访问c的位置的值属于非法访问，如果编译器已经将这块空间内容重置，取到的就有可能是随机值
那么临时变量存在哪呢？

1.如果c比较小（4 or 8字节），一般是寄存器充当临时变量
2.如果c比较大，一般在调用层的栈帧中

如果把传值返回改为传引用返回，就不会生成c的拷贝的临时变量，而是直接把c的引用返回，造成非法访问。如果在栈帧销毁时空间被清理，取c值取到的就是随机值（经验证，在VS下空间不会被清理）

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

再看这段代码

这里第二次调用Add函数时并没有对ret进行操作，但打印ret的值却变成了30，是因为第二次调用时把c空间的内容改变了。上面举的例子都是传引用的错误用法

那说了那么多，传引用返回到底怎么用呢？它的意义在那里呢？

传引用返回有一个原则：如果函数返回时，出了函数的作用域，返回对象还在（未还给系统），则可以使用引用返回，如果已经还给系统，则必须用引用返回。
传引用返回一般在C++的类和对象中用的比较多，也更能体现出它的价值，在这里只举一个简单例子帮助理解使用原则。

总结一下：引用的作用主要体现在传参和传返回值
1、引用传参和传返回值，有些场景下面，可以提高性能。（大对象+深拷贝对象–当返回对象太大，拿来拷贝的临时空间就需要开得很大，损耗大效率低，使用引用就不需要开辟那么大的空间）
2、做输出型参数和输出型返回值。通俗点说，有些场景下面，形参的改变可以改变实参。例如returnSize

常引用

int main()
{
	// 权限放大  不可以
	const int a = 10;
	int& b = a;
//加了const的a只读不可写，被b引用未加const，则可以通过b改变a，这是不行的

	// 权限不变 可以
	const int a = 10;
	const int& b = a;

	// 权限的缩小 可以
	int c = 10;
	const int& d = c;

	return 0;
}

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

引用和指针的不同点:

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