C++中的引用

1 引用的概念

引用不是新定义一个变量，而是给已存在变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它
引用的变量共用同一块内存空间。
格式：类型& 引用变量名(对象名) = 引用实体；
比如权游中的龙妈：她就有很多别名，比如，不焚者，卡丽熙反正都是龙妈。

我们可以看到变量a和变量的引用b的值都是23，毕竟公用一块内存空间。

注意：引用类型必须和引用实体是同种类型的

2 引用的特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

void TestRef()
{
 int a = 10;
 // int& ra; // 该条语句编译时会出错
 int& ra = a;
 int& rra = a;
 printf("%p %p %p\n", &a, &ra, &rra); 
}

3 常引用

void TestConstRef()
{
 const int a = 10;
 //int& ra = a; // 该语句编译时会出错，a为常量
 const int& ra = a;
 // int& b = 10; // 该语句编译时会出错，b为常量
 const int& b = 10;
 double d = 12.34;
 //int& rd = d; // 该语句编译时会出错，类型不同
 const int& rd = d;
 }

const 修饰a，则a不能被更改，也就是只读，但是你给它取了别名ra，就想扩大它的权限变为可读可写这肯定是不行的，所以第一句代码会编译出错，引用时也要加上const，
字面常量10也是可读的，所以同理。
至于最后一个就比较有趣了。double d = 12.12;int a = d;这样会隐式类型转换，即使会丢精度但是编译还是可以>过的，因为double 在准换成int时候，会产生临时变量，这个临时变量其实属于常量，所以取别名(引用)要加const

4 使用场景

4.1 作为参数

void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

4.2 作为返回值

int& Count()
{
 static int n = 0；
 n++;
 // ...
 return n;

int& Add(int a, int b) {
 int c = a + b;
 return c; 
 }
int main()
{
 int& ret = Add(1, 2);
 Add(3, 4);
 cout << "Add(1, 2) is :"<< ret <<endl;
 return 0; }

这段程序运行的结果是

是不是很诡异，为甚会是7呢，其实c是临时变量会被销毁，而函数返回的是c的引用，所以这感觉像是野指针，
引用了已经不属于自己的空间，但是当调用产生main栈帧，Add栈帧，Add栈帧被释放，又重新执行了栈帧，那块内存空间又被重新占用，所以最后是7而不是3。还是更粗暴的方式可以证明，比如看如下代码

int& ret = Add(1, 2);
	printf("chenzhihao\n");
	cout << "Add(1, 2) is :" << ret << endl;
	system("pause");
	return 0;

结果就成了下面的随机值，因为返回的引用指向的那块内存空间被释放后，又被printf()函数占用，所以是随机值。

注意：如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给 系统了，则必须使用传值返回。

5 传值、传引用的效率比较

以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是
传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是
当参数或者返回值类型非常大时，效率就更低。下面通过代码来验证下。

5.1 值和引用的作为参数的性能比较

#include <iostream>
#include <windows.h>
#include <time.h>

using namespace std;

struct A{ int a[10000]; };

void TestFunc1(A a){}

void TestFunc2(A& a){}

void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

int  main()
{
	TestRefAndValue();
	system("pause");
	return 0;
}

结果如下： 立竿见影

5.2 值和引用的作为返回值类型的性能比较

#include <iostream>
#include <windows.h>
#include <time.h>

using namespace std;

struct A{ int a[10000]; };

A a;

// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2(){ return a; }
void TestReturnByRefOrValue()
{
	// 以值作为函数的返回值类型
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1();
	size_t end1 = clock();
	// 以引用作为函数的返回值类型
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2();
	size_t end2 = clock();
	// 计算两个函数运算完成之后的时间
	cout << "TestFunc1 time:" << end1 - begin1 << endl;
	cout << "TestFunc2 time:" << end2 - begin2 << endl;
}


int  main()
{
	TestReturnByRefOrValue();
	system("pause");
	return 0;
}

结果如下： 立竿见影

6 引用和指针的区别和联系

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
 int a = 10;
 int& ra = a;
 
 cout<<"&a = "<<&a<<endl;
 cout<<"&ra = "<<&ra<<endl;
 return 0；
 }

在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
 int a = 10;
 
 int& ra = a;
 ra = 20;
 
 int* pa = &a;
 *pa = 20;
 
 return 0; }

我们来看下引用和指针的汇编代码对比

发现了吗，汇编代码一样的。因为引用是按照指针方式来实现的。搜嘎了吧。

总结：
1. 引用在定义时必须初始化，指针没有要求
2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型
实体
3. 没有NULL引用，但有NULL指针
4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占
4个字节)
5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
6. 有多级指针，但是没有多级引用
7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
8. 引用比指针使用起来相对更安全