#include<iostream>
using namespace std;

void f()
{
	int a = 10;
	int& ra = a;

	cout << "a  = " << a << endl;
	cout << "ra = " << ra << endl;

	printf("&a  : %p\n", &a);
	printf("&ra : %p\n", &ra);
}

int main()
{
	f();
	return 0;
}

?注意：引用类型必须和引用实体是类型相同

?二、引用特性

1.引用在定义时必须初始化，不能为NULL

#include<iostream>
using namespace std;

void f()
{
	int a = 10;
	int& ra;//编译会报错，需要指定ra是谁的引用
}

int main()
{
	f();

	return 0;
}

2.一个变量可以有多个引用，即可以有多个别名

#include<iostream>
using namespace std;

void f()
{
	int a = 10;
	int& ra = a;
	int& rb = a;
    int& rc = ra;

	cout << "ra = " << ra << endl;
	cout << "rb = " << rb << endl;
    cout << "rc = " << rb << endl;
}

int main()
{
	f();

	return 0;
}

这块空间既叫做a，又叫做ra、rb、rc?

（3）引用一旦引用一个实体，就不能再引用其它实体

三、常引用

1.常引用声明?

常引用声明方式：const ?类型& 引用变量名 = 目标变量名

#include <iostream>
using namespace std;

int main()
{
	const int a = 10;
	const int& ra = a;//正确常引用

    int& ra1 = a;//错误常引用

	return 0;
}

int& ra1?= a是错误引用，是因为变量a使用了const关键字，表明a的值不能被修改。但ra1作为a的引用，并没有使用const关键字，说明ra1的值可以被修改，这会导致权限被放大，编译器不允许：

虽然权限放大不被允许，但是权限缩小是允许的：目标变量没有const关键字修饰，常引用使用const关键字修饰，如下所示：

#include <iostream>
using namespace std;

int main()
{
	int b = 20;
	const int& rb = b;

	return 0;
}

2.带有隐式类型转换的常引用

隐式类型转换：编译器自动将一种类型转换成另一种类型，是编译器的一种自主行为

在隐式类型转换过程中，会产生一个临时变量，类型为目标变量类型。

int c = 10;
double d = 1.11;

d = c;//隐式类型转换，将int类型赋值为double类型

带有隐式类型转换的常引用如下所示：

int c = 10;
const double& rc = c;//带有隐式类型转换的常引用，将int类型赋值为double类型

（1）const修饰带有隐式类型转换引用的必要性

这是因为在隐式类型转换过程中，发生了类型赋值，这时候不是把c给rc，而是产生了一个临时变量，临时变量是double类型的。因此rc引用的并不是c，是这个过程中产生的临时变量，而临时变量具有常性，不可修改，因此rc要加上const关键字进行修饰。

（2）const修饰带有隐式类型转换引用的原因

?如果rc不加const关键字进行修饰，rc引用临时变量，临时变量不可修改，但是rc又可读可写，那么rc即引用的权限就被放大了，这是不允许的。

监视可以看到程序执行完毕时，c的值并没有发生变化，d≠c，rc≠c，d和rc改变的是临时变量的值。

四、使用场景

1.做参数

引用可以做参数，可以代替指针的作用

如Swap函数，指针的写法如下，有多处使用"*"解引用

//指针写法
void Swap(int* left, int* right)
{
	int temp = *left;
	*left = *right;
	*right = *left;
}

?如果用引用做参数，不需要解引用，不需要使用"*"

//引用写法
void Swap(int& left, int& right)
{
	int temp = left;
	left = right;
	right = left;
}

2.做返回值

先了解传值返回，再了解传引用返回?

（1）传值返回

传值返回，返回的是返回对象c的拷贝，不拿c做返回值，c只是Add的临时变量，Add函数调用结束后，c就不在了，因此不能返回c，返回的是临时变量。

#include<iostream>
using namespace std;

int Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int ret = Add(1, 2);

	return 0;
}

如何证明产生了这个临时变量？如下，使用ret接收返回值

#include<iostream>
using namespace std;

int Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(1, 2);

	return 0;
}

但编译不通过?

根据常引用声明，这是权限被放大导致的编译错误。c没有使用const进行修饰，ret也没有使用const进行修饰，为什么会导致权限放大呢？这是由于中间产生了临时变量，临时变量具有常性，不可修改。

所以ret也应该被const修饰，传引用返回的c的引用，即临时变量的名称，也是c的别名，把c的别名给了ret。

#include<iostream>
using namespace std;

int Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	cosnt int& ret = Add(1, 2);//用const修饰引用

	return 0;
}

（2）传引用返回

传引用返回，返回的是返回对象c的引用(别名)，当调用完Add函数，return返回后，Add的栈帧被销毁了，但是它使用的内存空间还在，只是使用权不属于它了，所以再去访问那块内存空间时，内存空间有可能没被清空，也有可能被清空了，因此有可能是以前的值，也有可能是随机值，所以代码的运行结果是不确定的。

#include<iostream>
using namespace std;

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(1, 2);
	Add(5, 7);

	cout << "ret = "<<ret << endl;

	return 0;
}

当调用Add(5,7) 时，调用的是同一个函数，在同一位置上再建立一个栈帧，栈帧大小是一样的，c的位置也一样，仅仅只是把c的位置的内容由3改成了12，因此ret的值也为12。

但如果调用Add(1,2) 后，下次调用的不是Add函数，是其他函数，那么c的位置的值会被改成其他内容。比如调用Add(1,2)后，再打印HelloWorld，那么会打印随机值。

#include<iostream>
using namespace std;

int& Add(int a, int b)
{
	int c = a + b;
	return c;
}

int main()
{
	int& ret = Add(1, 2);
	printf("Hello world\n");

	cout << "ret = "<<ret << endl;

	return 0;
}

因此实际中，如果出了函数作用域，返回对象就不存在了，不能用引用返回。如果非要用引用返回，就要使用static关键字，延长变量的生命周期，Add函数调用完毕，栈帧销毁，但是静态区不会销毁，栈帧销毁对函数局部变量没有影响。

#include<iostream>
using namespace std;

int& Add(int a, int b)
{
	static int c = a + b;//栈帧销毁对c没有影响
	return c;
}

int main()
{
	const int& ret = Add(1, 2);
	Add(5, 7);

	cout << "ret = " << ret << endl;

	return 0;
}

什么时候使用传值返回，什么时候使用传引用返回呢？

如果函数返回时，出了函数作用域，如果返回对象还在（还没还给操作系统），可以使用引用返回，如果已经还给系统了，必须要用传值返回。

传值传参和传值返回、传引用传参和传引用返回

TestFunc1传值，TestFunc2传引用

#include<iostream>
#include<time.h>
using namespace std;

struct A 
{ 
	int a[10000]; 
};

void TestFunc1(A a)
{
}

void TestFunc2(A& a)
{
}

void TestRefAndValue()
{
	A aa;
	
	//以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		TestFunc1(aa);
	}
	size_t end1 = clock();

	//以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; i++)
	{
		TestFunc2(aa);
	}
	size_t end2 = clock();

	//分别计算两个函数运行结束后的时间
	cout << "TestFun1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFun2(A)-time:" << end2 - begin2 << endl;

}
int main()
{
	TestRefAndValue();
	return 0;
}

传值传参和传值返回：在传参和返回期间，形参是实参的一份拷贝，返回变量是变量本身的一份拷贝，实参和变量本身占多大空间，形参和返回变量就占多大空间，在函数内操作副本，对该变量的修改并不会修改函数外部的变量。

传引用传参：形参和实参是同一个东西，实际操作的就是该变量，由于引用是指向某个变量的，对引用的操作其实就是对他指向的变量的操作，因此函数内对变量进行修改的话，外部变量也会被相应修改。

如果不希望修改变量的值，需要选择传值而不是传引用。但传引用往往比传值效率要高。

五、引用和指针

int a = 10;

//引用：在语法上，这里给a这块空间取了一个别名，没有开辟新空间
int& ra = a;
ra = 20;

//指针：在语法上，这里定义了一个指针变量，开了4个字节空间，存储a的地址
int* pa = &a;
*pa = 20;

1. 引用是别名，指针是地址

2. 引用在定义时必须初始化，指针没有要求

3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体，指针可以被重新赋值以指向另一个不同的变量。

4. 没有NULL引用，但有NULL指针

5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

7. 有多级指针，但是没有多级引用

8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

9. 引用比指针使用起来相对更安全。? ? ? ?这是由于，从编译上看，程序在编译时分别将指针和引用添加到?符号表上，符号表上记录变量名、变量地址。指针变量在符号表上对应的地址值为指针变量的地址，而?引用在符号表上对应的地址值为?引用对象的地址值。符号表生成后就不会再更改，指针可以改变指向的对象（指针变量中的值可以改），而引用对象不能改（第（3）条）。因此引用比指针更安全。如：

int a= 10;
int b = 30;  
int*& rpa = pa;//rpa是pa即int*的别名，此时pa指向a
rpa = &b;//rpa作为pa的引用，rpa的值被修改了，因此pa的值也被修改了，现在rpa和pa的值都为b的地址

printf("&a = %p\n", &a);
printf("&b = %p\n", &b);
printf("rpa = %p\n", rpa);
printf("pa = %p\n", pa);