引用——C++

---

引用的定义：

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

---

模板：

类型& 引用变量名(对象名) = 引用实体

void test1()
{
	int a = 1;
	int& ra = a;
	ra = 2;

	char b = 'b';
	char& rb = b;
	rb = 'c';

	//错误例子:引用类型必须和引用实体类型一致
	//short c = 3;
	//int& rc = c;
	//rc = 4;
	cout << a << ' ' << b << endl;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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

---

引用特性

1. 引用必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，则不能在引用其他的实体

void test2()
{
	int a = 10;
	
	//int& ra;//未初始化，会报错
	int& ra = a;
	int& rra = a;
	int& rrra = rra;

	printf("%p %p %p %p", &a, &ra, &rra, &rrra);

}
1
2
3
4
5
6
7
8
9
10
11
12

---

常引用

引用不但可以引用变量，还可以引用常数，不过需要const修饰，限定一下引用的权限

void test3()
{
	const int a = 10;
	const int& ra = a;

	const int& b = 10;

	double d = 12.34;
	const int& rd = d;//在进行类型转化的时候会创建一个临时变量来存储d，
//这个临时变量拥有常属性，可认为是一个常量，所以需要用const修饰的引用来引用这个常量
//相当于const int& rd = 12.34;
}
1
2
3
4
5
6
7
8
9
10
11
12

引用的权限可以缩小可以平移但不能放大：

引用可以用const修饰来缩小权限，比如把用const修饰的引用来引用一个变量；但不能用没有const修饰的引用来引用常量，这样权限会放大，是不被允许的

void test4()
{
	//错误示范：
	//1.引用常变量，需要const来修饰
	const int a=10;
	int& ra=a;
	//2.类型转换产生的临时变量具有常属性，需要有const修饰引用
	double d = 12.34;
	int& rd = d;
	//3.引用常量，需要const来修饰
	int& c = 10;
}
1
2
3
4
5
6
7
8
9
10
11
12

---

使用场景:

1. 做参数
   函数调用的时候，引用做参数，相当于把实参传过来（输出型参数），直接对实参进行修改，指针是通过地址间接对实参进行修改

void Swap(int& num1,int& num2)
{
    int tmp=num1
	num1 = num2;
	num2 = tmp;
}
1
2
3
4
5
6

当实参具有常属性时，或者不想要在函数中改变实参，形参需要用const来修饰

void Swap(const int& num1,const int& num2)
{
	int a=num1;
	int b=num2;
	//num1虽然接收的是变量a，但是经过const来修饰，具有常属性，不能改变，对引用进行了权限的限定
	//num2本身接受的就是常量，必须要有const修饰才可以接收
}

int main()
{
	int a=10;
	Swap(a,5)
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2. 做返回值（引用返回）
   可以把函数里面创建的变量（不能存在于栈区）返回本身

int& Count()
{
	static int n = 0;//变量存在静态区，不会因为出栈而销毁
	n++;
	return n;
}
1
2
3
4
5
6

错误示例：

int& Count()
{
	int n = 0;//变量存在栈区，会因为出栈而销毁，导致返回的值为一个随机值
	n++;
	return n;
}
1
2
3
4
5
6

注意：

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

原理：

在返回时，会创建一个临时变量，将要返回的内容根据函数的返回类型进行拷贝，然后返回的是这个拷贝
当传值返回时，对这个值进行拷贝，数据进行了保存，函数的因出栈销毁，但拷贝存在其他地方没有被销毁，返回的是这个拷贝
当传引用返回时，拷贝的类型是引用，相当于返回内容的别名，都指向同一块空间，即使出栈这片空间销毁，这个拷贝仍指向已被销毁空间，所以返回的变量不能创建在栈区，可以是全局变量或者存放在静态区（数据段），常量区（代码段）等其他不会被销毁的地方

内存空间的销毁意味着什么？

1. 空间还在吗？
   在，只是使用权不是我们的，放在里面的数据不被保护
2. 我们还能访问吗？
   能，只是我们读写的数据不确定的

---

传值、传引用效率比较

引用是不需要编译器给它开辟空间，它只是一个所引用对象的别名，都指向同一块空间

当我们在使用传值调用的时候，需要先对实参进行拷贝，将拷贝传递给形参，当实参数据量大的时候，传参效率低下

当我们使用传引用调用的时候，只是传过去一个实参的别名，仍指向该实参，不需要进行对实参进行拷贝，传参效率更好

#include 

struct A { int a[100000]; };
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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

通过上述代码的比较，发现传值和传引用在作为传参以及返回值类型上效率相差很大

传引用返回的作用：

1. 减少拷贝，提高效率
2. 可修改返回值
   

传引用做参数的作用：

1. 减少拷贝，提高效率
2. 输出型参数，在函数中修改形参，实参也会被修改

---

引用和指针的区别

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

int main()
{
	int a = 10;
	int& ra = a;
	cout<<"&a = "<<&a<<endl;
	cout<<"&ra = "<<&ra<<endl;
	
	return 0;
}
1
2
3
4
5
6
7
8
9

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

int main()
{
	int a = 10;
	
	int& ra = a;
	ra = 20;
	
	int* pa = &a;
	*pa = 20;
	
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

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

---

引用和指针的不同点:

1. 引用在概念上定义一个变量的别名，指针存储一个变量地址。

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全