C++入门--引用

1.引用的概念

• 引用概念：引用不是定义一个新的变量，而是给已经存在的变量去一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量公用同一块内存空间。
  举个例子就比如水浒传中的李逵，在梁山被称作为“铁牛”，在江湖被称做“黑旋风”。
  
  如上图所示：b就是a的别名。

• 语法： 数据类型& 引用变量名称 = 引用实体（变量）；
  
  由上图所示：b作为a的引用，它和a的地址是相同。说明a与b是属于同一个地址。

• NOTE:引用类型必须和引用实体是同一种类型的。

2.引用的特性

1. 引用在定义时必须进行初始化（光有外号没有人给谁起外号呢）。
   
   

2. 一个变量可以由多个引用（相当于一个人可以由好几个别名）。
   

3. 引用一旦引用一个实体，再不能引用其它实体。
   

3.常引用

• 常引用：语法：const 数据类型& 引用数据名称 = 引用实体；定义之后的变量只能被读而不能进行改写。
• 权限：权限可以虽小但是不能扩展。
• 示例：

int main()
{
	//权限扩大 a是只读的作为a的拷贝b不能扩大自己权限。
	//const int a = 20;
	//int& b = a;

	//权限保持
	//const int c = 20;
	//const int d = c;

	//权限缩小
	//int a = 10;
	//const int& b = a;
	return 0;
}

还需要注意的是：

int main()
{
	//这个是正确的因为这不是权限扩大，仅仅是进行赋值
	const int m = 10;
	int n = m;
	return 0;
}

还有一个例子：

int main()
{
	int a = 10;
	cout << (double)a << endl;//隐式类型转换
	double b = (double)a;//显示类型转换 
	//不管是隐式类型转换还是显示类型转换都不是真正对a本身进行改变，而是创建一个临时变量拷贝a，强制转变成double类型
	//而临时变量具有常性
	//因此下面代码是错误的
	int& c = b;
	//正确代码
	const int& c = b;
	return 0;
}

4.引用使用场景

1. 做参数 进行引用传参
   
   如上图所示，引用做参数和指针类似。形参能够改变实参。
   这样的好处：它可以减少拷贝，因为都是对同一段地址进行修改，避免了拷贝。

2. 做返回值 进行引用返回

#define N 10
typedef struct Array
{
	int a[N];
}AR;
//引用做返回值
//取a[i]的值
int& PostAt(AR& ar, int i)
{
	assert(i < N);
	return ar.a[i];
}
int main()
{
	//int a = 1;
	//int b = 0;
	//cout << a << endl;
	//cout << b << endl;
	AR ar;
	//我们可以对a[i]进行赋值 //调用者可以修改返回值对象
	for (int i = 0; i < N; i++)
	{
		PostAt(ar, i) = i * 10;
	}
	for (int i = 0; i < N; i++)
	{
		cout << ar.a[i] << " ";
	}
	cout << endl;
	
	return 0;
}

另外引用在运算符重载中也会被使用：

#define N 10
typedef struct Array
{
	int& at(int i)
	{
		assert(i < N);
		return a[i];
	}//临时变量具有常性 返回的时候不能改变
	int& operator[](int i)//运算符重载
	{
		assert(i < N);
		return a[i];
	}
	int a[N];
	int size;
}AR;

int main()
{
	AR ar;
	//for (int i = 0; i < N; i++)
	//{
	//	ar.at(i) = i * 10;
	//}
	//for (int i = 0; i < N; i++)
	//{
	//	cout << ar.at(i) << " ";
	//}
	//cout << endl;
	for (int i = 0; i < N; i++)
	{
		ar[i] = i * 10;
	}
	for (int i = 0; i < N; i++)
	{
		cout << ar[i] << " ";
	}
	cout << endl;
	return 0;
}

下面展示一个错误案例进行分析:

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;
	cout << "Add(1, 2) is :" << ret << endl;
	return 0;
}

返回值结果为：

问题来了为什么返回值是随机值呢？
答案就是在函数运行时，系统需要给该函数开辟独立的栈空间，用来保存该函数的形参，局部变量以及一些寄存器信息等。函数结束之后，该函数对应的栈空间就被系统收回了。空间被收回是指该空间已经无权访问了，但是该内存依然存在，只是返回给操作系统了。系统清理该片空间了，这片空间的值就是随机值。

• NOTE: 如果函数返回时，出了函数作用域，如果返回对象还在（也就是还没有返回给系统）（一般包括静态区变量、全局变量、部分局部变量，malloc的，上一层栈帧的等等），则可以使用引用返回，如果已经换给系统了（引用返回结果就是未定的了），则必须使用传值返回。

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

• 引用作为参数效率比较

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

#define N 100000
#include <time.h>
struct A { int a[N] = {}; };
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();
	return 0;
}

• 引用做返回值效率比较

#define N 100000
#include <time.h>
struct A { int a[N] = {}; };
void TestFunc1(A a) 
{
}
void TestFunc2(A& a) 
{
}
A a;
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestRefAndValue()
{
	A a;
	// 以值作为函数参数
	size_t begin1 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc1(a);
	size_t end1 = clock();
	// 以引用作为函数参数
	size_t begin2 = clock();
	for (size_t i = 0; i < 100000; ++i)
		TestFunc2(a);
	size_t end2 = clock();
	// 分别计算两个函数运行结束后的时间
	cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
	cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

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();
	//TestRefAndValue();
	return 0;
}

通过上述代码的比较，发现传值和指针在作为传参以及返回值类型上效率相差很大。

6.引用和指针的区别

在语法概念上引用就是一个别名，没有独立的空间，和引用实体是公用一块空间的。但是在底层实现上实际上是有空间的，因为引用是按照指针方式来实现的。

• 引用和指针的不同点：

1. 引用概念上定义一个变量的别名，指针存储一个变量地址。
2. 引用在定义时必须要初始化，指针没有要求。
3. 引用在初始化时引用一个实体后，就不能再引用其它实体了，而指针可以再任何时候指向任何一个同类型的实体（改变指针指向）。
4. 没有NULL引用，但又NULL指针。
5. 在sizeof中的含义不同：引用结果为引用类型的大小，但是指针始终是地址空间所占自己个数。
6. 引用自加即引用实体自加1，而指针自加即指针向后偏移一个类型的大小。
7. 有多级指针，但是没有多级引用（不会出现int&& b = a;这种情况）
8. 访问实体的方式不同，指针需要解引用，引用编译器自己处理。
9. 引用比指针使用起来安全。（不需要解引用，不能多级引用，比如使用指针可能会出现野指针的情况，如果操作失误，可能会访问不合法的空间，造成我们不想看到的后果，但引用不会。并且引用一旦定义， 即与当前所引用实体绑定，不能再引用其他实体， 这个规则一定程度上也使得引用在使用时更加安全。）