初始C++(三)：引用

一.引用的概念

引用的作用是给一个已经存在的变量取别名，编译器不会为引用变量开空间，引用变量和被他引用的变量共用一块空间。

二.引用的使用

//类型& 引用变量名(对象名) = 引用实体；
int i = 10;
int& j = i;//j就是i的引用，也可以说j就是i的别名

上面的i和j公用一块空间：

完全可以认为i,j代表的是一个东西。比如对i++使i变成11的时候，j也会变成11：

1.引用作为输出型参数

在我们学C语言的时候，应该遇到过交换函数，就是要求写一个函数来交换两个变量的值，当时是这样写的：

void Swap(int* i, int* j)
{
	int tmp = *i;
	*i = *j;
	*j = tmp;
}

因为函数的形参是实参的一份临时拷贝，也就是说形参的改变不会影响到实参的变化，所以这里我们要传递需要改变的两个变量的地址，这样在Swap函数里解引用才能找到需要改变的两个变量的值。
但是每次使用都要传地址，这样显得就非常麻烦，于是C++里的引用在这里就派上了大用场，现在这个交换函数可以这样写：

void Swap1(int& i, int& j)
{
	int tmp = i;
	i = j;
	j = tmp;
}
int main()
{
	Swap1(10,20);
	return 0;
}

这里的形参i,j不是实参的临时拷贝了，而是两个实参的别名，对两个别名的交换就可以认为是对实参两个变量的交换。

2. 引用作为函数返回值

首先看这样的一段代码：

int f()
{
	int n = 0;
	n++;
	return n;
}

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

来了解一下n这个值是怎么传给ret的：
1.在f()这个函数运行完之前变量n的值首先会拷贝到一个临时变量中。
2.然后f()函数结束，这个函数的空间被销毁
3.最后临时变量的值赋值给变量ret.

小知识点：临时变量

如果需要拷贝的值很小，临时变量可以是用寄存器来代替，如果很大，比如像一个结构体，那这个临时变量是在f()的上层函数中直接帮你开辟好的，这个上层函数可以认为是调用f()函数的函数，临时变量具有常性，可以理解为被const修饰了一样。
在函数值返回，隐式/显式类型转换的时候都会产生临时变量

int a = 10;
cout << (double)a << endl;//这里是显式转换
double b = a;//这里是隐式转换

接下来在看一段代码：

int f1()
{
	static int n = 0;
	n++;
	return n;
}

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

虽然这里的n变成了静态的变量,储存在静态区，f()函数销毁后n不会被销毁，但是计算机仍然会将n拷贝到一个临时变量中，然后再由这个临时变量返回给ret.

这里的变量n完全可以不用进行拷贝，所以上面的代码可以进行一些优化：

int& f1()//将值返回变成引用返回
{
	static int n = 0;
	n++;
	return n;
}

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

如果将值返回变为引用返回，返回的值将不再是临时变量，而是n的引用，也可以说返回的就是n这个变量。这样就可以减少中间拷贝的过程。
所以在返回的变量在函数销毁的时仍然存在的情况下，返回值就可以用引用返回。

明白了这一点，还可以写这样的一种代码：

//定义一个数组结构体
typedef struct Array
{
	int a[10];
}Array;

//定义一个函数用来寻找数组中第i个位置上的值
int& at(Array& ay, int i)
{
	assert(i < 10);
	return ay.a[i];  
	//形参用引用来接收，ay.a[i]中的ay是main函数中定义的那个数组的别名
	//返回值用引用，返回的就是main函数中定义的那个数组的别名
}

int main()
{
	Array ay;    //定义一个结构体
	for (int i = 0; i < 10; i++)
	{
		//既然返回值就是自己定义的结构体里的数组，
		//所以对其赋值也是完全可以
		at(ay, i) = i;
	}
	for (int i = 0; i < 10; i++)
	{
		cout << at(ay, i) << ' ';
	}
	cout << endl;
	return 0;
}

通过这段代码，引用返回不但可以减少拷贝，还可以对返回值进行修改。这里的at函数返回的就是数组里第i个元素，at(ay, i) = i就可以认为对第i个元素进行赋值。

3.const引用

先说结论：指针/引用在初始化和赋值的时候只能权限保持和权限缩小，不能权限放大。

权限放大：

int main()
{
	const int a = 10;
	int& b = a;
	return 0;
}

变量a的类型是const int说明它具有常属性，也就是不能被改变，但是a的别名b的类型是int反而可以改变了，这就是所谓的权限放大。如果这样写代码，编译器会报错的。

权限保持/权限缩小：

int main()
{
	//权限保持
	const int a = 10;
	const int& b = a;

	//权限缩小
	int x = 10;
	const int& y = x;
	return 0;
}

权限保持和缩小是没问题的。指针在这一块和引用是一样的，这里就不再复述了。

三.引用的一些小问题

1. 引用类型必须和引用实体是同种类型的
2. 引用在定义时必须初始化
3. 一个变量可以有多个引用
4. 引用一旦引用一个实体，再不能引用其他实体

四.引用和指针

在语法概念这个层次上引用是不开空间的，而指针是需要开空间的。接下来通过代码的汇编指令，看看引用和指针有没有区别：

int main()
{
	int a = 10;

	int* pa = &a;
	*pa = 20;

	int& ra = a;
	ra = 20;

	return 0;
}

虽然你可能不懂这些指令是什么，但你只要看指针和引用有没有区别就行。
不难发现，引用和指针在底层的指令是一模一样的。所以说，虽然表面上引用和指针是两码事，但在底层，引用其实就是指针。

五.引用和指针的区别

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