练习 ~黑马程序员匠心之作-第三阶段C++核心编程-P89~P94-C++中的引用

黑马程序员匠心之作|C++教程从0到1入门编程

1、引用的基本使用

作用：给变量起别名
语法：数据类型 &别名=原名

//引用的基本语法
	//数据类型 &别名 = 原名
	int a = 10;
	//创建引用
	int &b = a;
	cout <<"a=" << a <<endl;
	cout <<"b=" << b << endl;
    //修改b后a也随之变化
	b = 20;
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

2、引用的注意事项

1、引用必须初始化
2、引用在初始化后不可改变
原因：引用的本质在C++内部实现是一个指针常量，指针常量是指针指向不可修改，所以引用不可修改

int a = 10;
	int &b = a;
	//int &b; //错误的，必须初始化
	int c = 200;
	b=c; //正确，这是赋值操作，不是更改引用
	//int &b = c;//错误的，初始化后，不可修改
	cout <<"a=" << a <<endl;
	cout <<"b=" << b << endl;
	cout << "c=" << c << endl;

3、引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修改实参
优点：可以简化指针修改实参
引用传递的效果和地址传递的效果相同，引用的语法更加清楚简单
注意：当函数形参为值传递时，在调用函数前，调用者会创建对象的副本当作实参，函数内部负责销毁该副本，而引用传递则是把指向对象的指针当作形参传递

#include<iostream>
using namespace std;
 //交换函数
//1、值传递
void swap1(int a,int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "swap1 a=" << a << endl;
	cout << "swap1 b=" << b << endl;
}
//2、地址传递
void swap2(int *a, int *b)
{
	int temp = *a;//指针指向的值
	*a = *b;
	*b = temp;
	cout << "swap2 a=" << *a << endl;
	cout << "swap2 b=" << *b << endl;
}
//3、引用传递
void swap3(int &a, int &b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "swap3 a=" << a << endl;
	cout << "swap3 b=" << b << endl;
}
int main()
{

	int a = 10;
	int b = 20;
	swap1(a, b);//值传递，形参不会修饰实参

	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	swap2(&a, &b);//地址传递，形参修饰实参
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	swap3(a, b);//引用传递，形参修饰实参
	cout << "a=" << a << endl;
	cout << "b=" << b << endl;

	system("pause");
	return 0;
}

1、初始 int a = 10;int b = 20;，经过值传递后，swap1内输出交换后的值swap1 a=20;swap1 b=10主函数内实参不变a=10;b=20;
2、初始 int a = 10;int b = 20;，经过地址传递后，swap2内输出交换后的值swap2 a=20;swap2 b=10主函数内实参改变a=20;b=10;
3、初始 int a = 20;int b = 10;，（此处用的是第二步改变后的a和b）经过引用传递后，swap3内输出交换后的值swap3 a=10;swap3 b=20主函数内实参改变a=10;b=20;

4、引用做函数返回值

作用：引用是可以作为函数的返回值存在的
注意：不要返回局部变量引用
用法：函数调用作为左值

#include<iostream>
using namespace std;

//引用做函数返回值
//1、不要返回局部变量的引用
int& test01()
{
	int a = 10;//局部变量，存放在栈区，在test01执行完后会释放
	return a;
}


//2、函数的调用可以作为左值
int& test02()
{
	static int a = 10;//静态变量（提高生命周期），存放在全局区，全局区上的数据在程序结束后系统释放
	return a;
}

int main()
{
	int &ref = test01();//ref就是a,上面返回的a的别名，下面创建引用来接受
	cout << "ref=" << ref << endl;//第一次结果正确，是因为编译器做了保留
	cout << "ref=" << ref << endl;//第二次结果错误，是因为a的内存已经释放
	
	int &ref2 = test02();
	cout << "ref2=" << ref2 << endl;
	cout << "ref2=" << ref2 << endl;

	//返回值是引用，函数的调用可以作为左值
	test02() = 1000;//函数调用作为左值，且对其赋值操作，等价于a=1000的赋值操作
	cout << "ref2=" << ref2 << endl;//ref是a的别名，对a操作就是对其操作
	cout << "ref2=" << ref2 << endl;

	system("pause");
	return 0;
}

注意：
1、ref就是a，上面函数返回的a的别名，下面创建ref引用来接受。
2、test01中的a是局部变量，存放在栈区，在test01执行完后会释放。cout << "ref=" << ref << endl;第一次结果正确，是因为编译器做了保留，第二次结果错误，是因为a的内存已经释放。
3、test02中的a是静态变量（提高生命周期），存放在全局区，全局区上的数据在程序结束后系统释放。第一次和第二次结果皆正确。
4、返回值是引用，函数的调用可以作为左值，且对其赋值操作 test02() = 1000;，等价于a=1000；的赋值操作。ref是a的别名，对a操作就是对其操作，所以输出ref就是输出a。

5、引用的本质

本质:引用的本质在C++内部实现是一个指针常量（指向不可以修改，指向的数据可以修改）

#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=" << a << endl;
	cout << "ref=" << ref << endl;

	func(a);

	system("pause");
	return 0;
}

注意：
1、函数体内发现是引用，转换为int* const ref = &a;
2、main函数内也自动转换为int* const ref=&a;
3、指针常量是指针指向不可修改，也说明为什么引用不可修改。
4、int& ref = a;ref = 20;内部发现ref是引用，自动帮我们转换为：*ref=20;
5、C++推荐使用引用，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器都帮我们做了

6、常量引用

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

#include<iostream>
using namespace std;

//常量引用
//引用使用场景，通常用来修饰形参，防止误操作
//打印数据函数
void showValue(const int& val)
{
	//val = 1000;//const不可修改
	cout << val << endl;
}

int main()
{

	//int a = 10;  int& ref = a;//合法的
	//int& ref = 10;//不合法的，引用必须引一块合法的内存空间
	//const int& ref = 10;//合法，加入const就可以了，编译器优化代码将其改为：int temp=10;const int& ref=temp;
	//ref = 20;//错误，加入const后变为只读,不可以修改

	int a = 100;
	showValue(a);

	system("pause");
	return 0;
}

注意：
1、int& ref = 10;不合法的，引用必须引一块合法的内存空间，如：int a = 10; int& ref = a;
2、const int& ref = 10;加入const就合法了，编译器优化代码将其改为：int temp=10;const int& ref=temp;但是不可以修改它的值，如：ref = 20;是非法的
3、void showValue(const int& val)，引用使用场景，通常用来修饰形参，防止误操作