C++引用(内含和指针的对比)

1.引用的概念

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

类型& 引用变量名(对象名) = 引用实体；（&这个符号我们可能会看成取地址或者按位与，但是在这里是引用的意思，前面是类型，后面是变量，因为C++兼容C，所以这个符号有多重意思）

int main()
{
	int a = 0;
	int& ra = a;//定义引用类型

	return 0;
}

解释：ra就是引用，也是a的别名

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

2.引用和原本变量的关系

因为引用就相当于取了个别名，所以都是一个意思，以上面代码为例，a就是ra，ra就是a（鲁迅就是周树人，周树人就是鲁迅）

看这段代码就可以很好理解，它们的地址一样，自增的时候也是加到一个地方，所以没有区别

3.引用的特性

3.1引用在定义时必须初始化

引用实质是“取别名”，所以我们在取别名之前要先有一个名字（变量），可以看到，先定义接下来再初始化会直接报错（语法问题）

3.2引用不能改变指向 

当我们引用已经指向一个变量，就不能再改变它的指向。代码如下，当我们定义出b引用指向a，就不能再让b指向c（代码不会报错，但是不能改变指向，只是赋值）

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

 代码结果就是会把c的值赋给b（b是a的别名，所以b改变a也会改变）

3.3一个变量可以有多个引用

一个变量是可以有多个引用的，也可以是引用的引用，最后这些引用都是这个变量a的别名，其中一个改变其他三个都会改变。

4.常引用

4.1可以权限缩小

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

我们定义一个a的引用b，当我们++b的时候，a也会++，但是我们现在不想改变a要怎么办：

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

当我们给b加上const的时候，b就不能改变了，这也叫做权限的缩小，因为a是可读可写（写：可以改变）的，但是定义出来的b是可读不可写的，这就是权限的缩小，是允许的 

4.2可以权限平移

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

我们知道10是常量，常量不能改变，这时候赋给a一个常量就要加上const，现在a是可读不可写的，当我们把a赋给b的时候，b也要是可读不可写的，所以b也要加const，这是权限的平移，是允许的

4.3不能权限放大

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

 现在我们的a是一个可读不可写的值，当把a赋给b的时候，b是可读可写的，这样就是权限的放大，是不允许的

5.引用能不能代替指针

引用和指针功能是类似的（引用的出现是对指针使用比较复杂的的场景进行一些替换，让代码简单易懂，但是不能替代指针）

引用不能替代指针的原因：引用定义后，不能改变指向

就以双向不循环链表为例

struct Node
{
	struct Node* next;
	struct Node* prev;
	int val;
};

就以上面链表为例，我们想释放第二个，就得让第一个的next指向第三个，第三个的prev指向第一个，这个时候引用就不能代替指针

6.使用场景

6.1引用做返回值的陷阱

学了引用，有人可能想着拿引用做返回值，这个时候可能就会掉进陷阱

int& Fun()
{
	int a = 10;
	return a;
}
int main()
{
	int ret = Fun();
	cout << ret << endl;

	return 0;
}

这段代码看着没什么问题，打印也能正常打印出10，为什么会错误呢?（ret接收到的是a的别名，Fun函数结束调用就会释放，释放之后a就会销毁，这个时候我们的ret取的值可能是对的也可能会改变，取决于a会不会被处理）

如果想用引用做返回：全局变量，静态变量（static），堆上（malloc）变量都可以用引用返回，因为它们出了作用域生命周期不会结束

6.2引用做参数

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}
int main()
{
	int i = 0;
	int j = 1;
	Swap(i, j);
	cout << "i=" << i << endl;
	cout << "j=" << j << endl;

	return 0;
}

我们可以做参数直接用引用接收，这个时候在Swap函数里面交换 x 和 y 也会影响到外面的 i 和 j，相比于之前的C语言指针，我们少了传地址然后再解引用的操作。

6.3引用做返回值

int& Fun()
{
	static int a = 10;
	return a;
}
int main()
{
	int ret = Fun();
	cout << ret << endl;

	return 0;
}

看了返回值的陷阱，这部分就很好理解，我们里面用static修饰就会变成静态变量，函数销毁跟a就没关系了，所以就可以放心用引用返回

7.引用和指针的区别

我们这里从语法和底层做对比，不要把语法和底层混淆了，语法就是我们理解它的规定，底层就是从更深的层面去了解，所以说语法和底层是不一样的

语法：

1.引用是别名，不开空间，指针是地址，需要开空间存地址

2.引用必须初始化，指针可以初始化也不要不初始化

3.引用不能改变指向，指针可以

4.引用相对更安全，没有空引用，但是有空指针，容易出现野指针，但是不容易出现野饮用

5.sizeof、++、解引用访问等反面的区别

（上面这几点是比较重要的）

底层：

汇编层面上，没有引用，都是指针，引用编译后也转换成指针了

源代码：

int main()
{
	int a = 10;
	int& ra = a;
	ra = 20;
	int* pa = &a;
	*pa = 20;

	return 0;
}

汇编代码： 

 从上面汇编可以看出，引用的底层也是指针，不用看懂上面汇编，对比着看就可以了