C++引用

一、引用的概念

在我们的现实生活中，一个人经常不只一个名字，比如有一个人叫张伟，但是其他人又在日常生活中给他取了很多绰号，比如张大炮，张益达，斯内克；在古代，这种情况也很常见，比如宋江又叫及时雨，李逵又叫黑旋风、铁牛等等；我们把上面这些外号叫做别名。

引用就是给一个已经存在的变量取别名，编译器不会为引用变量开辟内存空间，它和它所引用的变量共用同一块内存空间。引用的符号和C语言中取地址的符号一样：&；在某类型名的后面加上引用符号 (&) 就变为了引用类型。设计引用的目的是简化指针的使用，但是引用不能完全代替指针 (实际上引用的底层是用指针实现的)。

int main()
{
	int a = 10;
	int& ra = a;       //定义引用类型 
	printf("%p\n", &a);
	printf("%p\n", &ra);
	return 0;
}

注意事项

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

二、常引用

1. 对同类型变量进行引用

常引用就是在引用类型前面用 const 进行修饰，和 const 修饰变量一样，被 cosnt 修饰的引用只能读，不能写，即不能修改引用变量的值。

引用普通变量时，可以用常引用；引用常变量时，只能用常引用

int main()
{
	int a = 10;
	int& ra = a;
	const int& rra = a;

	const int b = 20;
	//int& rb = b;    //非法引用
	const int& rrb = b;
}

因为指针和引用赋值过程中权限只能被缩小，不能被放大。普通变量 a 的权限是读写，引用变量 ra 的权限是读写，rra 的权限是只读，将权限为读写的 a 赋值给它们两个，一个是权限平移，一个是权限缩小，都没问题；

普通变量 b 的权限是读写，引用变量 rrb 的权限是只读，所以将 b 赋值给 rb 属于权限扩大，编译器报错。

2. 对常量进行引用

在C语言的学习中，我们知道可以用一个变量的地址对指针进行初始化，也可以直接赋给指针一个地址；同样我们不仅可以对变量进行引用，还可以对常量进行引用，只不过是常引用。

int main()
{
	//int& ra = 10;  //错误引用，权限扩大
	const int& rra = 10;  //对常量和常变量都需要进行常引用
    return 0;
}

底层原理：数字10只存在于指令中，在内存中并不占用空间，所以当我们对其进行引用时，10会先赋给一个临时变量，然后再对这个临时变量进行引用；而临时变量具有常性，即临时变量是只读的，所以我们需要用常引用来引用这个临时变量。

3. 对不同类型的变量进行引用

它的底层原理和上面是相似的：当我们的引用类型和变量类型不同时，该变量会先被赋值给一个与引用同类型的临时变量，相当于隐式类型转换，然后我们对这个临时变量进行引用，由于临时变量具有常性，所以我们需要用常引用来引用这个临时变量。

int main()
{
	double b = 13.14;
	//int& rb = b; //错误引用，权限扩大
	const int& rrb = b; //常引用，明智的选择
    return 0;
}

变量 b 和 rrb 的地址不同也说明 rrb 没有直接引用 b，证明了临时变量的存在。

三、引用的使用场景

1. 引用做函数参数

//单链表
typedef int SLTDataType;  
typedef struct SListNode   //链表的一个节点
{
	SLTDataType data;
	struct SListNode* next; 
}SLTNode;

//在头部插入数据
void SListPushFront(SLTNode*& phead, SLTDataType x)  //引用做形参，可以直接改变头指针
{
	SLTNode* newNode = BuySLTNode(x);  //开辟新节点
	newNode->next = phead;
	phead = newNode;
}

引用做函数参数的优点

1. 减少空间浪费，提高程序效率：我们知道，形参是实参的一份临时拷贝，既然是拷贝，就会有时间和空间上的开销；而引用是实参的别名，相当于我们直接对实参进行操作，没有数据拷贝的过程。

2. 引用可以直接改变实参，输出型参数可以不再传递指针，非输出型参数可以使用常引用。

比如单链表的头插操作，由于我们之前实现的单链表是不带头结点的，所以我们需要传递 plist 的指针，方便插入第一个数据时能改变 plist，现在我们可以直接使用 plsit 的引用即可，不用再传递二级指针了，这使得代码更易理解。

2. 引用做函数返回值

程序在调用函数时要在栈区上开辟函数栈帧，当调用完毕后该函数栈帧会自动销毁，由于函数中的各种局部变量以及函数形参都是在函数栈帧中分配空间的，所以当我们调用完函数后再去访问函数中的局部变量，编译器就会报错，因为该空间已经被操作系统回收。

那么函数的返回值是怎么返回到函数外面的呢？实际上，函数的返回值会先被拷贝到一个临时变量中，如果返回值较小，比如四个字节，那么临时变量就由寄存器充当；如果函数的返回值较大，比如是一个结构体，那么就由调用此函数的函数在其自身函数栈帧中开辟一块空间来充当临时变量，然后再把这个临时变量返回到函数外面。

int& Func()
{
	int n = 0;
	n++;
	printf("&n：%p\n", &n);
	return n;
}

int main()
{
	int ret = Func();
	cout << ret << endl;
	printf("&ret：%p\n", &ret);

	int& rret = Func();
    cout << rret << endl;
    cout << rret << endl;
	printf("&rret：%p\n", &rret);
	return 0;
}

在 Func 函数中，n 是局部变量，所以当 Func 函数调用结束后，n 的空间会被操作系统回收，同时我们用引用做返回值，相当于直接将 n 这个变量返回给了函数外的接收者，如果我们是用一个引用来接收的话，就相当于给 n 起了一个别名 rret，所以 n 和 rret 的地址是一样的。第一次打印的值也是一样的，因为 n 的空间被操作系统回收后并没有被其他程序占用，而是会保持原来的值，当执行一次打印操作后，n 原来的空间被新的函数栈帧覆盖，所以第二次打印会变成随机值。

所以我们意识到：当函数结束后会被销毁的变量不能用引用返回，那么什么变量才不会被销毁呢？当然是静态变量啦

int& Func()
{
	static int n = 0;
	n++;
	printf("&n：%p\n", &n);
	return n;
}

int main()
{
	int ret = Func();
	cout << ret << endl;
	printf("&ret：%p\n", &ret);

	int& rret = Func();
    cout << rret << endl;
    cout << rret << endl;
	printf("&rret：%p\n", &rret);
	return 0;
}

在 Func 函数中，n 由于是静态变量，在静态区中开辟空间，所以当 Func 函数的栈帧销毁后 n 并不会被销毁；同时我们用引用做返回值，相当于直接将 n 这个变量返回给了函数外的接收者，如果我们用一个引用来接收的话，就相当于给 n 起了一个别名 rret，所以 n 和 rret 的地址是一样的，值也不会发生改变。

总结

如果函数返回时，出了函数作用域，返回对象还在(还没还给操作系统)，就可以使用引用返回；如果已经还给了操作系统，则必须使用传值返回。

引用做返回值的优点

• 减少一次数据拷贝，节省空间，提高效率；
• 直接返回变量本身，从而可以通过返回值修改变量。

四、性能比较

1. 传值和传引用调用

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

struct A 
{ 
	int a[10000]; 
};

void TestFunc1(A a)
{
	
}

void TestFunc2(A& a)
{
	
}

//A TestFunc1()
//{
//	return a;
//}
//
//A& TestFunc2()
//{
//	return a;
//}

//A TestFunc1(A a) 
//{
//	return a;
//}
//
//A& TestFunc2(A& a) 
//{
//	return a;
//}

void TestRefAndValue()
{
	A a;
	// 以值作为函数参数和返回值
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1(a);
	size_t end1 = clock();

	// 以引用作为函数参数和返回值
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2(a);
	size_t end2 = clock();

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

2. 返回值和返回引用

struct A 
{ 
	int a[10000]; 
};
A a;
//void TestFunc1(A a)
//{
//	
//}
//
//void TestFunc2(A& a)
//{
//	
//}

A TestFunc1()
{
	return a;
}

A& TestFunc2()
{
	return a;
}

//A TestFunc1(A a) 
//{
//	return a;
//}
//
//A& TestFunc2(A& a) 
//{
//	return a;
//}

void TestRefAndValue()
{
	
	// 以值作为函数参数和返回值
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1(a);
	size_t end1 = clock();

	// 以引用作为函数参数和返回值
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2(a);
	size_t end2 = clock();

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

两者因素相加

通过上述代码的比较，我们发现传值和传引用以及返回值和返回引用效率相差是很大的，所以以后写函数我们要多用引用来提高效率。

五、引用和指针的关系

在语法概念上，引用就是一个别名，没有独立空间，和其引用实体共用同一块空间；但是在底层实现上，引用和实体并没有共用同一块空间，引用有自己的空间，它通过指针来访问实体空间。

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	
	int b = 10;
	int* pb = &b;
	*pb = 20;
	return 0;
}

虽然引用在底层是用指针实现的，但是它和真正的指针还是有很多区别：

• 语法概念上：引用定义一个变量的别名，指针存储一个变量的地址；
• 引用在定义时必须初始化，指针没有要求；
• 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以随时改变指向的对象。
• 没有NULL引用，但有NULL指针；
• 有多级指针，但是没有多级引用；
• 访问实体方式不同，指针需要显式解引用，引用不需要，因为编译器会在底层自动处理；
• 引用比指针使用起来相对更安全，因为没有野指针。

引用能在某些方面简化指针的使用，而且比指针更安全，但是不能完全替代指针，因为指针的功能更强大，引用能做的事情指针都能做，熟练正确地使用指针也是相当重要的。