引入

一.引用的基本使用

(1)引用的概念：

(2)引用的表示方法

(3)引用注意事项

(4)引用权限

二.引用的本质

三.引用与函数

(1)引用做函数参数

(2)引用做函数返回值

四.常量引用

五.引用与指针

引入

绰号，又称外号，是人的本名以外，别人根据他的特征给他另起的名字，大都含有亲昵、憎恶或开玩笑的意味。那么在C++中，为了可以给一个已存在的变量取别名，产生了引用。引用就是给已经存在的变量取别名。

一.引用的基本使用

(1)引用的概念：

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

(2)引用的表示方法

类型 & 别名 = 原名；

小白： &不是按位与吗？

小明：这是其实是运算符重载。通过重载，同一个运算符将会有不同的含义。编译器会通过上下文来确定运算符的含义。

小白：啊，原来如此，我说&怎么还是取地址符呢，懂了。

代码实例

#include <iostream>
using namespace std;
int main() {
	int money = 99999;
	int& money_1 = money;
	cout << "money=" << money<<endl;
	cout << "money_1=" << money_1<<endl;
	return 0;
}

小白：果然他们的值是相等的，那怎么确定他们共用一块内存空间呢？

小明：我们一起来调试看一下。

小明：看，引用和它引用的对象是同一块地址。

小白：学会了，小明厉害啊。

(3)引用注意事项

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

2. 一个变量可以有多个引用，但一个引用只能引用一个变量。

3. 引用一旦初始化，就不可更改。

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

由于引用是对已经存在的变量进行取别名，因此使用引用时必须指定变量(初始化)。

int& a;//错误，未初始化

2.一个变量可以有多个引用，但一个引用只能引用一个变量

在C++语法中，一个变量有多个引用，就类似于一个人可以有多个外号。但是一个引用变量只能指向一个引用对象。

代码实例：

#include <iostream>
using namespace std;
int main() {
	int x = 100;
	int& y = x;
	int& z = x; 
	return 0;
}

3. 引用一旦初始化，就不可更改。

引用一旦指向引用对象后，不可以更改引用对象。

小白：啊啊啊，好多内容，脑袋记不住啊！

小明：不急慢慢来，你哪里不明白？

小白：为什么一个引用只能引用一个对象？

小明：你想，如果一个引用类型同时是两个对象的别名，那计算机编译时怎么知道应该用哪一个呢？

小白：也就是说，同时指向多个对象时，具有二义性？

小明：对的。

小白：那为什么初始化后，不能更改引用对象啊？

小明：这个涉及引用的本质，文章后面会讲到的。

小白：好的，我会继续努力的。

(4)引用权限

引用原则:对原变量的引用，权限不能放大。

代码实例：

#include <iostream>
using namespace std;
int main() {
	int x = 100;
	int& y = x;
	//权限不变可行
	const int& z = x; 
	//权利缩小可行
	return 0;
}

权限没有扩大可行

代码实例：

#include <iostream>
using namespace std;
int main() {
	const int x = 100;
	int& y = x;
	//权限扩大可行
	const int& z = x; 
	//权利不变可行

	return 0;
}

存在权限扩大不可行。

小白：这个我知道，就像班长指挥军长干活，军长上去就是一脚。

小明：哈哈哈哈，对，权限不能扩大，只能缩小

二.引用的本质

引用的本质是C++内部实现的一个指针常量

代码实例：

#include <iostream>
using namespace std;
int main() {
	int a = 10;
	int& b = a;
	//本质：int* const b=&a
	b = 100;
	//本质：*b=100;
	return 0;
}

小白：原来如此，这就解释了为什么初始化后，不能更改引用对象了。

小明：对的，因为const修饰b，b中存储的值不能改变，因此b指向的内存地址不能改变，所以引用初始化后不能更改引用对象。

小白：这个引用本质，还是有点糊涂......

小明：你可以这样理解，当代码编译到int& b=a时，编译器其实执行int* const b=&a,当执行b=100时，编辑器实际执行*b=100。

小白：我可以理解为这两种写法是一样的，只是引用简化了吗？

小明：可以的。

三.引用与函数

(1)引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参，也更安全

一般认为函数传参有两种形式，值传递和地址传递。值传递的形参是对实参的一份临时拷贝。地址传递是传递指针，通过指针访问实参所在的内存区间。所以地址传递不用开辟新空间，因此速度更快，还能减少内存。

值传递代码实例：

#include <iostream>
using namespace std;
void swap(int x, int y) {
	int temp = x;
	x = y;
	y = temp;
	cout << "形参：" << "x=" << x << ' ' << "y=" << y << endl;
}
int main() {
	int x = 10, y = 20;
	swap(x,y);
	cout << "实参：" << "x=" << x <<' ' << "y=" << y << endl;
	return 0;
}

值传递不改变实参的值

地址传递代码实例：

#include <iostream>
using namespace std;
void swap(int* x, int* y) {
	int temp = *x;
	*x = *y;
	*y = temp;
	cout << "形参：" << "x=" << x << ' ' << "y=" << y << endl;
}

int main() {
	int x = 10, y = 20;
	swap(&x,&y);
	cout << "实参：" << "x=" << x <<' ' << "y=" << y << endl;
	return 0;
}

地址传递可以改变实参的值

小白：理解地差不多了，不过值传递的形参是对实参的一份临时拷贝是什么意思？

小明：我画个图你就知道了

小白：明白了，值传递就是从新开辟空间，只是内容一样而已

小明：对的。

小白：那地址传递呢？

小明：地址传递就是利用指针，形参是存储实参的指针，解引用就找到实参了。

小白：明白了，那引用做形参又是怎么回事？

小明：你忘了刚学的引用本质了？

小白：哦我明白了，这个代码让我来，嘿嘿。

#include <iostream>
using namespace std;
void swap(int& x, int& y) {
	int temp = x;
	x = y;
	y = temp;
	cout << "形参：" << "x=" << x << ' ' << "y=" << y << endl;
}

int main() {
	int x = 10, y = 20;
	swap(x,y);
	cout << "实参：" << "x=" << x <<' ' << "y=" << y << endl;
	return 0;
}

小明：没错，引用当形参就是这样写的。

小明：你能根据引用本质写出指针版本吗？

小白：小问题啦，看我大展身手。

小白：怎么样，我写的对吗？

小明：对的，其实引用也是地址传递，只是因为const的缘故，不能改变指向的对象而已。

小白：我明白了。

小明：相比指针，引用更加简便，而且因为const，比指针更加安全。

(2)引用做函数返回值

引用作为函数返回值特性：

1.不能返回局部变量的引用。

2.函数的调用可以作为左值。

小白：为什么引用不能返回局部变量的引用啊？

小明：引用本质是指针，是指针常量。因为指针不能返回局部变量的地址。

小白：指针不能返回局部变量的指针吗？

小明：是的，因为局部变量会在函数执行完之后销毁，该变量的内存会返回给系统，此时函数返回该变量地址，并且调用的话，属于非法访问，是失效指针。

小白：哦哦，明白了，也就是函数执行完之后，该地址不属于该程序了，再次访问是非法的。

小明：对的。

代码实例：

#include <iostream>
using namespace std;
int& test() {
	int n = 0;
	n = 100;
	return n;
}
int main() {
	int& res = test();
	cout << res << endl;
	cout << "系统清除" << endl;;
	cout << res<<endl;
	return 0;
}

注意：

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

小白：那只能创建全局变量，返回全局变量了吗？

小明：其实可是使用static关键字，static关键字创建在全局区(静态区)，生命周期是整个程序。

小白：static创建的变量，程序不停止，变量不销毁对吗？

小明：对的。

小白：还是有些懵。

小明：不急，我们来看一下代码就懂了。

代码实例：

#include <iostream>
using namespace std;
int& test() {
	static int n = 0;
	n = 100;
	return n;
}
int main() {
	int& res = test();
	cout << res << endl;
	cout << "系统清除" << endl;
	cout << res<<endl;
	return 0;
}

小白：懂了，只要返回值在函数调用不销毁就可以是吗？

小明：对的。

小白：那函数的调用可以作为左值，又是什么意思？

小明：就是说函数可以放到等号左边，给函数赋值。

小白：给函数赋值，不可能吧？

小明：实际上，函数返回值是引用时，会产生一个引用变量，只是没有名字，给函数赋值，实际就是给该引用赋值。

小白：还是不明白。

小明：我们来看代码。

代码实例：

#include <iostream>
using namespace std;
int& test() {
	static int n = 0;
	n = 100;
	return n;
}
int main() {
	int& res = test();
	test() = 99;
	cout << res<<endl;
	return 0;
}

小白：哦哦，也就是说此时函数相当于一个匿名的引用，函数当左值相当于通过匿名引用修改n的值。

小明：对的，那你看看下面代码什么意思。

代码实例：

#include <iostream>
using namespace std;
int& test() {
	static int n = 0;
	n = 100;
	return n;
}
int main() {
	int res = test();
	test() = 99;
	cout << res<<endl;
	return 0;
}

小白：int类型能接收int&类型的值吗？

小明：可以的，其实相当于吧匿名引用解引用后，把值传给res。

小白：还是不明白。

小明：我们接着看代码。

代码实例：

#include <iostream>
using namespace std;
int& test() {
	static int n = 0;
	n = 100;
	return n;
}
int main() {
	/*int res = test();*/
	int& m = test();
	int res = m;
	test() = 99;
	cout << res<<endl;
	return 0;
}

小明：这个明白吧。

小白：这个明白。

小明：那么换成匿名引用不懂了？

小白：懂了，也就是直接通过，匿名引用传值给变量。

小明：对的。

四.常量引用

const 类型 & 别名 = 原名；

1.可以直接指向一块常量。

2.函数形参列表中，可以防止形参改变从而改变实参。

小白：这个我懂相当于指向常量的指针常量。

小明：没错，例如const int* const p；p的值不能改变，*p的值也不能改变。

小白：可以直接指向一块常量，是什么意思？

小明：其实常量保存在常量区，声明周期和程序共存亡，并且常量区只有只读权限，没有写权限。如果用普通的引用，由于引用可以更给指向内存的值，属于权限扩大，会报错，使用常量引用则引用也只有读权限，则可以指向常量区。

小白：有些糊涂。

小明：没事，我们来看看代码。

代码实例：

#include <iostream>
using namespace std;
int main() {
	/*int& res = 10;*/
	const int& res = 10;
	cout << 10;
	return 0;
}

小白：明白了，防止实参改变，从而改变实参，是为了防止手误没小心改变形参吧。

小明：厉害，直到抢答了，某些场景我们只需要值，但不许要改变引用的值，可以使用常量引用，防止粗心改变形参的值。

代码实例：

#include <iostream>
using namespace std;
void text(const int& x) {
	//x = 100;
	cout << x;
}
int main() {
	/*int& res = 10;*/
	text(9);
	return 0;
}

五.引用与指针

引用其实就是指针，引用的本质是C++内部实现的一个指针常量，建设建立引用int& b=a时，编译器其实执行int* const b=&a,当执行b=100时，编辑器实际执行*b=100。之后遇到的b可以都看成指针常量的*p，但也要看上下文。其实引用也是占用空间的，只是被C++隐藏了。

宏观区别：
1.指针的值可以为空，但是引用的值不能为NULL，并且引用在定义的时候必须初始化；。
2. 引用在初始化时引用一个实体后，就不能再引用其他实体（指针常量），而指针可以在任何时候。指向任何一个同类型实体。
3. 在sizeof中含义不同：引用结果为引用类型的大小(sizeof(*p))，但指针始终是地址空间所占字节个数(4/8)。
4. 引用自增即引用的实体增加1((*p)++)，指针自增即指针向后偏移该类型的大小的字节。
5. 有多级指针，但是没有多级引用。
6. 访问实体方式不同，指针需要显式解引用，引用编译器编译器自行处理。