C++中引用的全方面总结（引用与指针，引用做形参，常量引用）

引用的基本概念

作用：给一个变量起别名

语法 ：数据类型 &别名 = 原名

变量名称就是那块内存的名字，往往原名比较复杂，我们通过起别名来解决

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int& b = a;
	cout << b << endl;
	cout << a << endl;
	return 0;
}

如果我们修改b的值，a的值也会随之改变，因为操作的是一块内存，而a,b是同一块内存

引用的注意事项

• 引用必须初始化
• 引用在初始化之后不可以改变

#include<iostream>
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	//int&c; 错误，引用必须初始化
	int& c = a;
	c = b;//这是赋值操作不是更改引用
	cout << a << endl;
	cout << b << endl;
	cout << c << endl;
	return 0;
}
//如果更改引用会报错
// 错误	C2374	“c”: 重定义；多次初始化

引用作为函数参数

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

优点：可以简化指针修改实参

#include<iostream>
using namespace std;
//如果使用函数重载的话，值传递和引用传递不能一起重载，这样调用的时候会报错显示不明确
void test(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
}
void change(int* a, int* b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
void change(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	//值传递，形参不会修饰实参
	test(a, b);
	cout << a << endl;
	cout << b << endl;
	//地址传递，形参会修饰实参
	change(&a, &b);
	cout << a << endl;
	cout << b << endl;
	//引用传递，形参会修饰实参
	change(a, b);
	cout << a << endl;
	cout << b << endl;
	return 0;
}

那修改的原理是什么呢？

我们调用传入的是值，但是接受的a是传入a的别名，本质上是同一段内存空间，对内存空间的修改就会改变实参

引用和指针有所区别

指针是传入内存空间地址直接进行操作

引用是传入值然后通过引用别名对别名进行操作

但都是可以实现形参修饰实参，引用语法相对于来说简单一点

引用做函数返回值

作用：引用是可以作为函数的返回值而存在的

注意：不要返回局部变量引用

用法：函数调用作为左值

#include<iostream>
using namespace std;
int& test01()
{
	int a = 10;//局部变量存放在四区的栈区
	return a;
}
int main()
{
	int&ref = test01();
	cout << ref << endl;
	cout << ref << endl;
	cout << ref << endl;
	return 0;
}

第一次的值是10后面则是混乱数据，因为内存已经被释放了，只是编译器给我们保存了一次

#include<iostream>
using namespace std;
int& test01()
{
	static int a = 10;//提示变量生命周期，静态变量存放在全局区
	return a;
}
int main()
{
	int&ref = test01();
	cout << ref << endl;
	cout << ref << endl;
	cout << ref << endl;
	return 0;
}

这样三个数据都是10，就不会出现问题了

函数调用做左值

#include<iostream>
using namespace std;
int& test01()
{
	static int a = 10;//提示变量生命周期，静态变量存放在全局区
	return a;
}
int main()
{
	int&ref = test01();
	cout << ref << endl;
	cout << ref << endl;
	cout << ref << endl;
	test01() = 1000;
	cout << ref << endl;
	cout << ref << endl;
	cout << ref << endl;
	return 0;
}

​ 前三个数据是10，后三个数据是1000

​ 本质上test01()就是a，ref是别名，也可以访问修改过后的那块内存

​ 如果函数的返回值是引用，那么这个函数调用可以作为左值

引用的本质

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

指针常量：指向不能修改，值可以修改（ohhhhhh)

#include<iostream>
using namespace std;
//发现是引用，转换为int* const ref = &a
void func(int& ref)
{
	ref = 100;
}
int main()
{
	int a = 10;
	//编译器自动转换为int* const ref = &a;指针常量是指针指向不可改，也侧面说明了为什么引用不可更改
	int& ref = a;
	ref = 20;
	//内部发现ref是引用，自动帮我们转换为：*ref=20;
	cout << a << endl;
	cout << ref << endl;
	//当我们调用函数的时候
	func(a);
	cout << a << endl;
	cout << ref << endl;
	return 0;
}

重点：

引用本质就是一个指针常量

引用不能修改指向，能修改值

常量引用

作用：常量引用主要用来修饰形参，防止误操作

在函数形参列表中，可以加入const修饰形参，防止形参改变实参

本质上就是将指针常量再度加一个const，变成既不能修改指向，也不能修改指向的值

#include<iostream>
using namespace std;
//这样在这个函数中ref不可修改
//在大型程序中可以有效的防止误操作，还可以有效的节约内存
void print(const int& ref)
{
	cout << ref << endl;
	
}
int main()
{
	int a = 100;
	//如果不加const是报错的
	//加上const之后，编译器将代码修改 int temp = 10; const int & ref = temp;
	const int& ref = 10; //引用必须引入一块合法的内存空间
	print(a);
	return 0;
}