C++系列-引用

引用的基本使用

引用的起源

• 将变量名作为实参：值传递，改变形参，实参并不改变。
• 将指针作为实参：实际上采用的也是值传递，只不过这里的值指的是变量的地址。
• 传送变量的别名：传递的是变量的地址，所以二者本身完全是同一个地址的变量。

引用的语法

• 数据类型 &别名=变量名
• & 引用声明符，别名和原变量代表的是同一变量单元
• 在传参数时，别名和原变量可以取同一个名字

引用的本质

• 给变量起别名。
• 引用的本质是一个指针常量（int * const p =&a;是个指针，该指针是常量）
• 指针常量的指向不可更改，但是该地址内的值可以更改，这就是引用一旦初始化为某一变量的别名后，再不能更改的原因。

• 在外部看，可以简化如下：

	code:
	#include 
	#include 
	using namespace std;
	int main()
	{
		int a = 666;
		int& b = a;		// 编译器内部自动转化为	int* const b = & a;
		b = 888;		// 发现是引用，自动转化为 *b=888;
		cout << "a的值:" << a << endl;
		system("pause");
	}
result:

引用的注意事项

• 引用在声明时，必须同时初始化。
• 必须引用合法的内存空间（int &a=10; 错的）。
• 在声明一个变量的引用后，不能再作为其它变量的别名。

code:
	int a = 10;
	cout << "address of a：" << &a << ", value of a：" << a << endl;
	int x = 20;
	cout << "address of x：" << &x << ", value of x：" << x << endl;
	int & b = a;	//引用声明
	
	cout << "address of b：" << &b << ", value of b：" << b << endl;
	b = x;			//是变量赋值，而不是将该引用作为其它变量的引用	
	cout << "address of a：" << &a << ", value of a：" << a << endl;
	cout << "address of b：" << &b << ", value of b：" << b << endl;	

result:
	address of a：000000D209FCFB34, value of a：10
	address of x：000000D209FCFB54, value of x：20
	address of b：000000D209FCFB34, value of b：10
	address of a：000000D209FCFB34, value of a：20		// a的值变为20
	address of b：000000D209FCFB34, value of b：20

引用和指针

• 不必设立指针变量，指针变量要开坡另外的内存空间，其内容是地址。二引用变量不是第一个独立的变量，不单独占用内存空间。
• 在函数调用时，并不需要再变量名前加取址符。
• 在&a前面有类型时，是引用，如 int &a, 否则为取址符。
• 改变形参，对于引用和指针，实参同时改变。

引用作为函数参数

• 引用作为函数形参，形参改变，实参改变。
• 不需要像指针那么复杂的操作。

值传递仅仅改变形参，实参不发生变化
code:
#include 
#include 
using namespace std;

void swap(int x, int y)
{
	cout << "值传递swap之前：x, y分别为: " << x << "," << y << endl;
	int temp;
	temp = x;
	x = y;
	y = temp;
	cout << "值传递swap之后：x, y分别为: " << x << "," << y << endl;
}

int main()
{
	int a1 = 666;
	int b1 = 888;
	cout << "值传递swap之前：a1, b1分别为: " << a1 << "," << b1 << endl;
	swap(a1, b1);
	cout << "值传递swap之后：a1, b1分别为: " << a1 << "," << b1 << endl;
	system("pause");
	return 0;
}

result:
	值传递swap之前：a1, b1分别为: 666,888
	值传递swap之前：x, y分别为: 666,888
	值传递swap之后：x, y分别为: 888,666
	值传递swap之后：a1, b1分别为: 666,888

指针作为参数，传递的是实参的地址值，那么对该地址的操作，会影响到实参。
code:
#include 
#include 
using namespace std;

void swap_pt(int *x, int *y)
{
	cout << "x, y地址分别为: " << x << "," << y << endl;
	cout << "值传递swap之前：*x, *y分别为: " << *x << "," << *y << endl;
	int temp;
	temp = *x;
	*x = *y;
	*y = temp;
	cout << "值传递swap之后：*x, *y分别为: " << *x << "," <<* y << endl;
}

int main()
{
	int a1 = 666;
	int b1 = 888;
	cout << "a1, b1地址分别为: " << &a1 << "," << &b1 << endl;
	cout << "值传递swap之前：a1, b1分别为: " << a1 << "," << b1 << endl;
	swap_pt(&a1, &b1);
	cout << "值传递swap之后：a1, b1分别为: " << a1 << "," << b1 << endl;
	system("pause");
	return 0;
}

result：
	a1, b1地址分别为: 00000006F5D4F904,00000006F5D4F924
	值传递swap之前：a1, b1分别为: 666,888
	x, y地址分别为: 00000006F5D4F904,00000006F5D4F924
	值传递swap之前：*x, *y分别为: 666,888
	值传递swap之后：*x, *y分别为: 888,666
	值传递swap之后：a1, b1分别为: 888,666

引用传递，实参和形参是同一变量
code:
#include 
#include 
using namespace std;

void swap_reference(int &x, int &y)
{
	cout << "x, y地址分别为: " << &x << "," << &y << endl;
	cout << "引用传递swap之前：x, y分别为: " << x << "," << y << endl;
	int temp;
	temp = x;
	x = y;
	y = temp;
	cout << "引用传递swap之后：x, y分别为: " << x << "," << y << endl;
}

int main()
{
	int a1 = 666;
	int b1 = 888;
	cout << "a1, b1地址分别为: " << &a1 << "," << &b1 << endl;
	cout << "引用传递swap之前：a1, b1分别为: " << a1 << "," << b1 << endl;
	swap_reference(a1, b1);
	cout << "引用传递swap之后：a1, b1分别为: " << a1 << "," << b1 << endl;
	system("pause");
	return 0;
}

result:
	a1, b1地址分别为: 0000003871CFFB14,0000003871CFFB34
	引用传递swap之前：a1, b1分别为: 666,888
	x, y地址分别为: 0000003871CFFB14,0000003871CFFB34
	引用传递swap之前：x, y分别为: 666,888
	引用传递swap之后：x, y分别为: 888,666
	引用传递swap之后：a1, b1分别为: 888,666

引用作为函数的返回值

• 要返回局部变量的引用。
• 如果函数的返回是个引用，则函数的调用可以作为左值。
• 不能返回函数内部通过new分配的内存的引用。

//不要返回局部变量的引用，局部变量在栈区，调用完毕后释放，有可能第一次使用该引用时，编译器可能还没释放，但是后面会出错
code:
	#include 
	#include 
	using namespace std;
	
	int & test()
	{
		int x = 100;
		return x;
	}
	
	int main()
	{
		int& ref = test();
		cout << "ref的值1:" << ref << endl;
		cout << "ref的值2:" << ref << endl;
		system("pause");
	}
result:
	ref的值1:632365056
	ref的值2:632365056

code:
	#include 
	#include 
	using namespace std;
	
	
	int& test_static()
	{
		static int x = 0;
		x += 666;
		return x;
	}
	
	int main()
	{
		int& ref = test_static();		// ref是函数中x的别名
		test_static() = 2000;			// test_static()返回的就是x的别名，相当对x=2000，
		cout << "ref的值:" << ref << endl;
		system("pause");
	}

result:
	ref的值:2000

常量引用

• 可以用于形参，防止误操作。

	code:
	#include 
	#include 
	using namespace std;
	
	int main()
	{
		int a = 666;
		//int& b = 888;			// 报错，必须引用合法的内存空间，888都不知道地址是什么
		const int &b = 888;		// 自动转化为 int temp = 888; const int &b = temp; 只能使用别名
		//b = 30;				// 不可再修改
		cout << "b的值:" << b << endl;
		system("pause");
	}

code：
	#include 
	#include 
	using namespace std;
	
	void print_data(const int& a)
	{
		//a = 100;		//错误，已经不可再修改
		cout << "a = " << a << endl;
	}
	
	int main()
	{
		int a = 666;
		print_data(a);
	}
result：
	a = 666

其它

code:
	#include
	using namespace std;
	float temp;
	float fn1(float r) {
		temp = r * r * 3.14;
		return temp;
	}
	float& fn2(float r) { //&说明返回的是temp的引用，换句话说就是返回temp本身
		temp = r * r * 3.14;
		return temp;
	}
	int main() {
		float a = fn1(5.0);			//case 1：返回值
		//float &b=fn1(5.0);		//case 2:用函数的返回值作为引用的初始化值 [Error] invalid initialization of non-const reference of type 'float&' from an rvalue of type 'float'
									//（有些编译器可以成功编译该语句，但会给出一个warning） 
		float c = fn2(5.0);			//case 3：返回引用	
		float& d = fn2(5.0);		//case 4：用函数返回的引用作为新引用的初始化值
		cout << a << endl;//78.5
		//cout<
		cout << c << endl;//78.5
		cout << d << endl;//78.5
		system("pause");
		return 0;
	}

用返回值方式调用函数（case 1）

• 返回全局变量temp的值时，C++会在内存中创建临时变量并将temp的值拷贝给该临时变量。
• 当返回到主函数main后，赋值语句a=fn1(5.0)会把临时变量的值再拷贝给变量a。
  

用函数的返回值初始化引用的方式调用函数（case 2）

• 函数fn1()是以值方式返回时，首先拷贝temp的值给临时变量。返回到主函数后，用临时变量来初始化引用变量b，使得b成为该临时变量到的别名。
• 由于临时变量的作用域短暂（在C++标准中，临时变量或对象的生命周期在一个完整的语句表达式结束后便宣告结束，也就是在语句float &b=fn1(5.0);之后） ，所以b面临无效的危险，很有可能以后的值是个无法确定的值
  
• 可以如下操作：

code:
	int x=fn1(5.0);		//x不释放
	int &b=x;

用返回引用的方式调用函数（case3）

• 函数fn2()的返回值不产生副本，而是直接将变量temp返回给主函数，即主函数的赋值语句中的左值是直接从变量temp中拷贝而来（也就是说c只是变量temp的一个拷贝而非别名） ，这样就避免了临时变量的产生。
• 尤其当变量temp是一个用户自定义的类的对象时，这样还避免了调用类中的拷贝构造函数在内存中创建临时对象的过程，提高了程序的时间和空间的使用效率。

用函数返回的引用作为新引用的初始化值的方式来调用函数（case4）

• 函数fn2()的返回值不产生副本，而是直接将变量temp返回给主函数。在主函数中，一个引用声明d用该返回值初始化，也就是说此时d成为变量temp的别名。
• 由于temp是全局变量，所以在d的有效期内temp始终保持有效，故这种做法是安全的。

注意：
本文中的部分内容来自伯乐在线