引用超详解

引用

引用的概念

引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量共用同一块内存空间。

• 引用特性
  • 引用在定义的时候就要初始化
  • 一个变量可以有多个引用
  • 引用一旦引用了一个实体就不能引用其它实体，引用的指向是不能更改的。（代表了引用不能完全替代指针,比如：在链表中引用就不能替代指针）

C++中引用和指针相辅相成

C++可以简化指针

引用的用处

1.引用做参数
做输出型参数（j解决的大多数问题，指针也可以解决）

//输出型参数
void Swap(int& left, int& right)
{
	int tmp = left;
	left = right;
	right = tmp;
}

引用做参数的意义
1、减少拷贝，提高效率
2、做输出型参数

2.引用做返回值

• 传值返回
  要弄清楚引用做返回值的问题，必须搞清楚函数是如何传值返回的！
  

• 引用返回
  
  
  中间添加一段对内存空间的理解
  
  测试一段代码

void func()
{
	int x = 100;
}
int& Count()
{
	int n = 0;
	n++;

	cout << &n << endl;
	return n;

}
int main()
{
	int& ret = Count();//此时意味着ret就是那块空间的别名，就是n的别名
	cout << ret << endl;
	cout << ret << endl;
	Count();
	cout << ret << endl;
	func();
	cout << ret << endl;
	return 0;
}

结果如下：

解释1：第一次打印，打印出来的是1，在Count栈桢销毁后，访问了之前存储着n的空间拿到了值，仍旧是原来的值。
解释2：第二次打印是一个随机值，是因为在调用cout函数时，原来的位置重新建立了一个函数站着，原来的值也就被覆盖。
解释3：同1，调用了一次Count函数后，拿到了原来的值。
解释4：同2，调用了func函数，在原来的位置又重新建立了一个func函数的栈帧，原来的值也被覆盖。

正确的使用

int Count1()
{
	int n = 0;
	n++;
	return n;
}
int& Count2()
{
	static int n = 0;
	n++;
	return n;
}

int main()
{
	int ret1 = Count1();
	int ret2 = Count2();
	cout << ret1 << endl;
	cout << ret2 << endl;

	return 0;
}

结论：
1.以上的所有结果都是不确定的，是错误的行为。
2.出了函数作用域，返回的变量不存在了，不能用引用返回，引用返回的结果是不确定的
3.出了函数作用域，返回变量存在，才能用引用返回

传引用返回意义：
1、减少拷贝，提高效率。（测试）（更大的意义，在于深浅拷贝）

#include <time.h>
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();
	return 0;
}

测试结果如下：

2、修改返回值

常量引用

//为了减少拷贝，用了一个引用,不怎么好，会影响实参的值，并且也只能调用一个非const的版本的参数
//加了const的，不会影响传过来的实参，还可以接受const和非const的参数
void Func(const int& x = 10)  //加const的之后可以使用缺省参数
{

}

int main()
{
	//权限的放大与缩小仅限于在指针和引用中
	int a = 0;
	int& ra = a;

	const int b = 1;//只可读
	//int& rb = b;  错误  变成了可读可写，权限放大了
	//权限的平移
	const int& rb = b;

	//权限的缩小
	const int& rra = a;
	a++;

	a = b;//拷贝，a不影响b

	Func(a);
	Func(ra);
	Func(rra);
    Func(10);
	return 0;
}

指针和引用的赋值中，权限可以缩小，但不能放大

int Count()
{
	int n = 0;
	n++;
	return n;
}
int main()
{
	const int& b = 10;
	double d = 12.34;

	//打印的是产生的临时变量
	cout << (int)d << endl;
	//语法规定：临时变量具有常性
	//int& ri = d;  错误
	const int& ri = d; //可以

	//int& ret = Count();   //传值返回不能用引用接受，返回的是临时变量，具有常性，要加const
	const int& rret = Count(); //可以
}

类型转换：中间产生了临时变量
隐式类型转换和强转都会产生临时变量
传值返回不能用引用接受，返回的是临时变量，具有常性，要加const

语法上面：ra是a的别名，不开空间
底层实现：需要开空间
一段代码的汇编即可说明

//语法上面：ra是a的别名，不开空间
//底层实现：需要开空间,引用底层是使用指针
int main()
{
	int a = 10;

	int& ra = a;
	ra = 20;

	int* pa = &a;
	*pa = 20;

	return 0;
}

指针和引用的区别（灰常重要！！！）

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