05—C++中的引用

01引用的基本语法

#include<iostream>
using namespace std;
#include<string>
//引用
/*
引用的基本使用：
作用：给变量起别名
语法：数据类型 &别名=原名
注意：别名的数据类型要和原名相同
*/
int main()
{
	//引用之后，两个变量操作同一块内存
	int a = 10;
	int &b = a;
	cout << a << endl;//10
	cout << b << endl;//10
	b = 20;
	cout << a << endl;//20
	cout << b << endl;//20
	system("pause");
	return 0;
}

02引用的注意事项

#include<iostream>
using namespace std;
#include<string>
//引用的注意事项
/*
1.引用必须初始化
int &b;	错误的，没有初始化
int &b=a; 正确的
2.引用在初始化之后不可以改变
*/
int main()
{
	//引用必须初始化
	int a = 10;
	int &b = a;
	//引用在初始化之后不可以改变
	int c = 20;
	b = c;//赋值操作，而不是更改引用
	cout << a << endl;//20
	cout << b << endl;//20
	cout << c << endl;//20
	system("pause");
	return 0;
}

03引用做函数参数

#include<iostream>
using namespace std;
#include<string>
//引用做函数参数
/*
参数的传递方式：值传递（不改变实参），地址传递（改变实参）

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修改实参

目前可以做到形参修饰实参的操作有两种：地址传递，引用传递
*/

//实现两个数字交换函数
//1.值传递
void swap01(int a,int b){
	int temp;
	temp = a;
	a = b;
	b = temp;
}
//2.地址传递
void swap02(int *a, int*b){
	int temp;
	temp = *a;
	*a = *b;
	*b = temp;
}
//3.引用传递
void swap03(int &a,int &b){
	//引用就是给变量起别名，两个名字指向同一个地址（名字可以相同），所以在这里改了，也相当于把实参改了
	int temp = a;
	a = b;
	b = temp;
}

int main()
{
	int a = 10;
	int b = 20;
	cout << "进行交换前实参的值" << "a=" << a <<"  "<<"b=" << b << endl;
	swap01(a, b);
	cout << "使用值传递进行交换后的实参的值" << "a=" << a << "  " << "b=" << b << endl;//值传递（不改变实参
	//swap02(&a, &b);
	//cout << "使用地址传递进行交换后的实参的值" << "a=" << a << "  " << "b=" << b << endl;//地址传递（改变实参）
	swap03(a,b);
	cout << "使用引用传递进行交换后的实参的值" << "a=" << a << "  " << "b=" << b << endl;
	system("pause");
	return 0;
}

04引用做函数的返回值

#include<iostream>
using namespace std;
#include<string>
//引用做函数的返回值
/*
作用：引用可以做函数返回值存在的
注意：不要返回局部变量引用
用法：函数的调用可以作为左值
*/

//1.不要返回局部变量引用
//创建一个引用的函数,等价于：int &Test01=a;
int & Test01(){
	int a = 10;//局部变量，创建在栈区，随着函数的调用结束，内存被释放
	return a;
}

//2.函数的调用可以作为左值
int & Test02(){
	//使用static关键字，将将局部变量的生命周期延长
	static int a = 10;//static关键字将局部变量，存放在全局区，在程序结束后内存才被系统释放
	return a;
}

int main()
{
	int &ref01 = Test01();
	cout << ref01<< endl;//第一次运行结果正确是因为编译器做了保留
	cout << ref01 << endl;//第二次，错误（当被调用结束内存已经被释放了）
	int &ref02 = Test02();
	cout << ref02 << endl;//10
	cout << ref02 << endl;//10
	//函数的调用作为左值：Test02()是原值，ref02是别名，原值的值改变，别名的值也会改变
	Test02() = 1000;//如果函数的返回值是一个引用，这个函数调用可以作为左值
	cout << ref02 << endl;//1000
	cout << ref02 << endl;//1000
	system("pause");
	return 0;
}

05引用的本质

#include<iostream>
using namespace std;
#include<string>
//引用的本质
//本质:引用的本质在C++内部实现是一个指针常量
//指针常量：int * const p；const修饰变量p，所以地址不能改变（指针指向不能改变）
//发现是引用，转换为 int* const ref = &a;

//注意：这些了解即可，我们用的时候还是把它当做别名使用，其他的交给编译器吧
void func(int & ref){
	ref = 100; // ref是引用，转换为*ref = 100
}
int main(){
	int a = 10;
	//自动转换为 int* const ref = &a; 指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a;
	ref = 20; //内部发现ref是引用，自动帮我们转换为: *ref = 20;
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;

	func(a);

	system("pause");
	return 0;
}

06常量引用

#include<iostream>
using namespace std;
#include<string>
//常量引用
/*
当我看到常量，首先要想到const

作用：常量引用主要用来修饰形参，放置误操作
在函数的形参列表中，可以加const修饰形参，防止形参改变实参
*/

//打印数据函数
//常量引用主要用来修饰形参，防止误操作
void showValue(const int &val)
{
	//val=10;//加上const之后这句就不能执行，防止误操作
	cout << "Val=" <<val<< endl;
}

int main()
{
	int a = 10;
	
	//1.引用必须指向一个合法的内存空间，这里直接给一个常量会报错：下面的语句会报告错
	//int & ref = 10;

	//当我们在引用前加上const的时候，编译器会把我们的代码修改为
	//int temp=10;	int & ref=temp;
	const int & ref = 10;
	//这个时候我们只能通过别名去操纵这段内存空间
	//但是加入const之后为只读状态，不可以修改其值
	//ref = 10;//错误
	cout << ref << endl;

	//2.常量引用主要用来修饰形参，防止误操作
	int b = 100;
	showValue(b);
	system("pause");
	return 0;
}