C++学习笔记 - 阶段三：C++核心编程 - Chapter2：C++中的引用

阶段三：C++核心编程

Chapter2：C++中的引用

2.1 引用的基本语法

作用：给变量起别名
语法：数据类型 &别名 = 原名
注意事项：引用操作相当于起别名，起了别名以后，两个名字操作的是同一段内存空间

#include "iostream"
using namespace std;

int main() 
{
	int a = 10;  //众所周知，这是创建一个变量a，并赋予其初值为10
	int& b = a;  //给变量a起一个别名为b
			     //注意这里的细节，a和b只是名称不同，但是二者操作的是同一段内存，所代表的数据是同一数据
				 //此时b就是a的别名，那么我们就可以通过修改b的数据来改变a，相反亦可。
				 //另一个需要注意的是：写法上 int& b 和 int &b 是完全一致的意思
	cout << "a = " << a << endl;//打印
	cout << "b = " << b << endl;
	
	b = 100;     //对b进行赋值修改，那么a也应该是100,这就是引用的操作
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	
	system("pause");
	return 0;
}

输出结果如下：

2.2 引用的注意事项

1.引用必须初始化
2.引用在初始化后，不可以改变

#include "iostream"
using namespace std;

int main() 
{
	int a = 10;
	int b = 20;  
	int& c = a;  //如果这里是这样写的 int &c;     //错误，引用必须初始化
	             //一旦初始化后，就不可以更改c是a的别名这种关系
	//int& c = b;//报错  “c” : 重定义；多次初始化，因为妄想要更改“c是a的别名”这种关系为“c是b的别名”
	c = b;       //这是赋值操作，不是更改引用
	cout << "a = " << a << endl;
	cout << "b = " << b << endl;
	cout << "c = " << c << endl;

	system("pause");
	return 0;
}

输出结果如下：

2.3 引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参。
优点：可以简化指针修改实参。
总结：通过引用参数产生的效果同按地址传递是一样的。引用的语法更清楚简单。
注意：值传递无法做到 形参修饰实参；
地址传递可以做到 形参修饰实参；
引用传递可以做到 形参修饰实参。
这里写交换函数，用三种数据传递来做示例，可以更清楚的发现区别。

#include "iostream"
using namespace std;

//方式1. 值传递
void  mySwap01(int a, int b) 
{
	int temp = a;
	a = b;
	b = temp;
	cout << "mySwap01  a:" << a << " b:" << b << endl;
}
//方式2. 地址传递
void mySwap02(int* a, int* b) //因为传进来的是地址，所以接收的得是指针   a表示的就是地址  *a表示的就是数据
{
	int temp = *a;
	*a = *b;
	*b = temp;
	cout << "mySwap02  a:" << *a << " b:" << *b << endl;
}
//方式3. 引用传递
void mySwap03(int& a, int& b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "mySwap03  a:" << a << " b:" << b << endl;
}

int main() 
{
	int a = 10;
	int b = 20;
	mySwap01(a, b);  //值传递   -> 形参不会修饰实参
	cout << "main1     a:" << a << " b:" << b << endl;
	cout << "====================" << endl;

	a = 10;
	b = 20;
	mySwap02(&a, &b);//地址传递 -> 形参会修饰实参
	cout << "main2     a:" << a << " b:" << b << endl;
	cout << "====================" << endl;

    a = 10;
	b = 20;
	mySwap03(a, b);  //引用传递 -> 形参会修饰实参
	cout << "main3     a:" << a << " b:" << b << endl;
	cout << "====================" << endl;
	
	system("pause");
	return 0;
}
/*
对上面的示例进行补充剖析：
*方式1. 值传递
在mySwap01函数内部确实是完成了局部变量的交换，
但是执行完该函数局部变量就被释放掉了，回到主函数，a和b依然还是之前的数据
*方式2. 地址传递
在mySwap02函数内部确实是完成了局部变量的交换，

*方式3. 引用传递
int a = 10; int b = 20;
调用的时候：mySwap03(a, b);
首先这里的mySwap03的参数a b就是实参的数据 a = 10; b = 20;
然后mySwap03是引用传递  mySwap03(int& a, int& b) 
也就是说当执行mySwap03(a, b);代码时，会发生：int& a = a;   int& b = b;
变量a的别名是a，变量b的别名是b，然后经过函数内部交换
数据交换肯定是可以的 因此引用传递是可以做到形参修饰实参的
*/

输出结果如下：

2.4 引用做函数返回值

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

#include "iostream"
using namespace std;

//返回局部变量引用
int& test01()         //函数前面加上&符号就是 用引用的方式进行返回
{
	int a = 10;       //局部变量存放在四区中的栈区， 用完之后就会被释放掉
	return a;
}
//返回静态变量引用
int& test02() 
{
	static int a = 20;//加上static就是静态变量，它存在于四区中的全局区，全局区上的数据在程序结束后被系统释放
	return a;
}

int main() 
{
	//test01 测试
	int& ref = test01();              //test01函数return a;那么就是 int& ref = a;然后a被释放了,相当于int& ref = NULL;所以这里会出错
	cout << "ref = " << ref << endl;  //第一次是对的，再多执行一次就错误了，是因为编译器只帮助保存一次，所以第一次不报错，但不采取
	cout << "ref = " << ref << endl;  //第二次是错的，是因为内存已经被释放了 无法操作，因此出来的数据都是乱的
	                                  //结论：不能返回局部变量的引用
    cout << "====================" << endl;
	//test02 测试
	int& ref2 = test02();             //test02函数return a;  那么就是 int& ref = a;a是static变量存在于全局区，能够保留下来
	cout << "ref2 = " << ref2 << endl;//第一次是对的
	cout << "ref2 = " << ref2 << endl;//第二次是对的
	                                  //结论：引用做函数返回值，返回值在函数内部定义的时候，必须加上static关键字，成为静态变量
    cout << "====================" << endl;
    //函数的调用可以作为左值 测试
	test02() = 1000;  //可以作为左值  这里相当于是 a = 1000; 
	                  //如果函数的返回值是引用，这个函数调用可以作为左值
                      //如果函数做左值，那么函数返回值必须是返回引用
	cout << "ref2 = " << ref2 << endl;//因为ref2是a的别名，a的数据变了 所以ref2也要变化
	cout << "ref2 = " << ref2 << endl;
    cout << "====================" << endl;
    
	system("pause");
	return 0;
}

输出结果如下：

2.5 引用的本质

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

#include "iostream"
using namespace std;

void func(int& ref)   //int& ref = a;ref是a的别名,两者共用同一段内存，因此&a和&ref是相同的
{                     //编译器发现是引用，会将 int& ref 转换为 int* const ref = &a;加上const就表明引用一旦发生，两者关系不可更改
	ref = 100;        //ref是引用，转换为 *ref = 100
	cout << "ref:" << ref << endl;
}

int main() 
{
	int a = 10;
	int& ref = a;
	ref = 20;         //编译器发现ref是引用，自动将其转换为: *ref = 20;
	
	cout << "a:" << a << endl;
	cout << "ref:" << ref << endl;
	cout << "====================" << endl;
	func(a);
	return 0;
}
/*
对上面的示例进行补充剖析：
当编译器看到 int& ref = a; 这样的代码时会将其自动转换为 int* const ref = &a;
int* const ref = &a;是什么意思呢？
a是一个变量，数据是10，假设地址是0x0011
那么ref的值就是0x0011，因为ref是存放地址的变量
而*ref就是10  这里的const修饰的是ref
也就是说ref指向a这个关系是不能改变的 ref不能再指向其他的内存了
指针的指向不能改 但是指针指向的内存存放的值是可以更改的
指针常量是指针指向不可改，也说明为什么引用不可更改
*/

输出结果如下：

2.6 常量引用

见到常量就要想到两个东西
1.#define 宏 2.const
这里的常量就是讲const
作用：常量引用主要用来修饰形参，防止误操作
在函数形参列表中，可以加const修饰形参，防止形参改变实参

#include "iostream"
using namespace std;

void showValue(const int& v) 
{
	//v += 10;
	//v = 1000;
	cout << v << endl;
}

int main() 
{
	/*
	int a = 10;
	int& ref = a;
	这是正确的，但是如果直接写成
	int& ref = 10;
	这是错误的，因为引用本身需要一个合法的内存空间，而这里的数据10没有提供这段内存空间，所以错误
	但是加入const就可以了，即 const int& ref = 10;
	因为编译器优化代码，int temp = 10; const int& ref = temp;
	我们找不到原名，因为原名是编译器帮助起好了 这里用temp代替表达意思
	因此我们只能拿到别名
	*/
	const int& ref = 10;
	/*
	那么 直接向ref赋值可以吗？  如：ref = 100;
	这是不可以的，因为加入const后不可以修改变量
	*/
	cout << ref << endl;

	//函数中利用常量引用防止误操作修改实参
	int a = 10;
	/*
	这个函数本设计用来只是打印了a的值是多少，
	如果这个函数原型的形参是这样定义的：showValue(int& v)
	那么这说明了在showValue函数内部是可以对a的值进行修改的，如果有什么代码更改了a的值的话，代
	码少可以看出来 如果代码多的话，看不到呢？
	这违背了本来只是向打印a的值的诉求。
	因此，我们要这样定义：showValue(const int& v) 
	*/
	showValue(a);

	system("pause");
	return 0;
}


//引用使用的场景，通常用来修饰形参
/*
showValue(int& v)
showValue(const int& v)
*/