C++基础——引用

1. 引用的概念

引用就是给已存在变量的别名，对引用的操作与对变量直接操作完全一样。

引用的定义方式为：

类型& 引用变量名(对象名) = 引用实体

int main()
{
	int a = 10;          // 定义一个变量a，其值是10

  * 类型& 引用变量名(对象名) = 引用实体 *
    int& b = a;          // 定义一个变量b作为a的引用
    b = 20;

	std::cout << a << std::endl;  // 观察a，b的值
	std::cout << b << std::endl;

	std::cout << "Address of a is:" << &a << std::endl;  // 观察a，b的地址
	std::cout << "Address of b is:" << &b << std::endl;

	return 0;
}

可以看到，对于b的修改同样使得a的值发生了变化，并且a与b拥有相同的地址，因此可以直观地得出结论——a，b指向同一块内存空间，是同一个变量的两个不同名字

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

2. 引用的特性

一般而言，使用引用时要遵循如下规则

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

引用的初始化： 

int main()
{
    // a未初始化，b作为a的引用 ———— 可以，因为为a开辟了空间
	int a;
	int& b = a;

	std::cout << "Address of a is:" << &a << std::endl;
	std::cout << "Address of b is:" << &b << std::endl;

    // 引用c未初始化 ———— 不可以，无法确定c作为谁的引用
	int& c;

	return 0;
}

单个变量的多个引用：

int main()
{
	int a;
	int& b = a;
	int& c = a;
	int& d = c;

	std::cout << "Address of a is:" << &a << std::endl;
	std::cout << "Address of b is:" << &b << std::endl;
	std::cout << "Address of c is:" << &c << std::endl;
	std::cout << "Address of d is:" << &d << std::endl;

	return 0;
}

引用初始化之后不能更改引用对象

int main()
{
	int a;
	int c = 10;
	int& b = a;

    // 此处是赋值操作，等价于 a = c 可以编译通过
	b = c;

    // 此处将b重新引用指向变量c，编译失败
	int& b = c;

	return 0;
}

3. 引用的使用场景

引用通常有两种使用场景，分别是

• 做参数
• 做返回值 

做参数

1. 引用做输出型参数

所谓的输出型参数是相对于输入型参数而言的，输入型参数是指将值作为某个函数的输入供你使用，输出型参数是指将值给某个函数，期望这个函数能够改变值，并且我能够拿到这个函数输出的值，典型的例子是交换两个数的值

在C程序中，形参的改变并不影响实参的改变，如果要在一个函数中对实参进行修改，要使用传址传参，使用引用可以避免使用指针来传址——只需要在形参的位置使用引用，如下面的代码x作为a的引用，y作为b的引用，这样可以直接在函数内完成对a和b的修改

void Swap(int& x, int& y)
{
	int tmp = x;
	x = y;
	y = tmp;
}

int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	std::cout << "a = " << a << std::endl;  // a = 20
	std::cout << "b = " << b << std::endl;  // b = 10

	return 0;
}

2. 引用作为大对象传参，可以提高效率

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

引用传参的过程中并没有生成临时变量，因而也就没用拷贝变量的消耗，特别是当变量足够大时，所带来的效率提升十分可观，用下面的代码来测试传值和传引用的效率

#include <time.h>

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();

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

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

可以看到传引用的效率会大大高于传值 

做返回值

引用也可以作为返回值，但必须在正确的情况下使用才能用好引用返回

考虑下面的代码，这是一个传值返回的例子，函数Count有自己的栈帧，在返回时栈帧会销毁，因此在返回时会产生一个临时变量作为n的拷贝，并用这个临时变量作为返回值赋给ret

int Count()
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int ret = Count();
	std::cout << ret << std::endl;
	return 0;
}

将代码做一点点的修改，使其变成传引用返回，在这种情况下，返回的是n的别名，这时生成的是一个临时的对象int& tmp作为返回值，此时ret也是tmp和n的别名，然而这时n和tmp的栈帧已经被回收，对于tmp的访问形成了越界，因此ret的结果是未定义的

程序在这里产生了错误，原因是n是一个局部变量存储在Count的栈帧中，Count返回时n所处的内存空间已经被销毁，使用引用返回会导致越界，得到错误的值

int& Count()
{
	int n = 0;
	n++;

	return n;
}

int main()
{
	int& ret = Count();
	std::cout << ret << std::endl;   //  1         第一次Count栈帧空间未清理，ret仍能找到原来的n
    std::cout << ret << std::endl;   // 2091297160 第二次调用时，上一次cout时将原来的栈帧空间改变了，打印出随机值
	return 0;
}

因此，如果出了函数作用域，返回对象就销毁了，那么一定不能用传引用返回，而是要使用传值返回

1. 传引用返回作为输出型返回对象，调用者可以修改返回对象 

为确保返回对象出了函数不销毁，我们可以用static修饰，下面的代码能够得到正确的值，此时的n并不在函数的栈帧内，而是作为局部符号被加载到程序内存空间.data段

int& Count()
{
	static int n = 0;
	n++;

	return n;
}

int main()
{
	int& ret = Count();
	std::cout << ret << std::endl;   // 1
	std::cout << ret << std::endl;   // 1

	return 0;
}

如果出了函数作用域，返回对象并不销毁，那么可以使用传引用返回

2. 大对象返回，提高效率

#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();

	// 计算两个函数运算完成之后的时间
	std::cout << "TestFunc1 time:" << end1 - begin1 << std::endl; // 147
	std::cout << "TestFunc2 time:" << end2 - begin2 << std::endl; // 1
}

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

 

4. 常引用

在C中，const修饰的变量权限为只读，这意味着我们不能修改这个变量，如果对于一个const修饰的变量，使用引用为这个变量取一个别名，必须要注意不能放大权限(可以使用相同的权限或者缩小的权限)，也就是说引用必须使用const dataeype& 

int main()
{
	int a = 10;
	int& b = a; 
    const& f = a;      // 权限可以缩小

	const int c = 20;
	int& d = c;        // 这里c无法修改，d可修改，将c的权限放大了，错误

    // 正确的做法
    const int& e = c;  // 相同的权限
    

	return 0;
}

另一方面，在隐式类型转换中，会产生一个临时变量，例如double b = a，a会先产生一个double类型的临时变量，这个临时变量具有常性，然后再将这个临时变量赋给b，完成隐式类型转换

而在引用中，如果要发生隐式类型转换，如下面代码第三行，c并非是a的引用，而是临时变量的引用，因此如果不见const，会发生权限的放大，导致出错

int main()
{
	int a = 10;       
	double b = a;
	double& c = a;       // 出错
	const double& c = a; // 正确
	return 0;
}

考虑下面的代码，在传值时会生成临时变量，因此对func1的三次调用都能成功

而在传引用时，变量b和常数30都具有常性，func2中的引用放大了权限，导致出错

func3中并没有放大权限，因此可以正确调用

void func1(int x)
{}

void func2(int& x)
{}

void func3(const int& x)
{}

int main()
{
	int a = 10;
	const int b = 20;

	func1(a);
	func1(b);
	func1(30);

	func2(a);
	func2(b);     // 错误
	func2(30);    // 错误

	func3(a);
	func3(b);
	func3(30);

	return 0;
}

 如果使用引用传参，且函数内不改变x，那么尽量用cons引用传参

5. 引用和指针的区别

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

引用和指针的不同点:

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