【C++】之引用详解 什么是引用？

目录

一、引用的概念

二、 引用特性

三、 常引用

四、 引用的使用场景

4.1 做参数

4.2 做返回值(传引用返回)

五、传值、传引用效率比较

5.1 函数传值与传引用

5.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); 
}

三、 常引用

加了 const 该变量是不能修改的，即成了一种常量，可以理解为只读型，而没加 const 的可理解为可读可写型。

 //权限的平移 --- 两者都是可读可写型
 int a = 10;
 int & b = a;

---

权限放大：

//--- 权限放大 --- 

//只读型(const)
const int a = 20;

//可读可写型  报错！
int &b= a;      × × ×

//权限平移
const int &c = a;   √ √ √ 

权限缩小：

//--- 权限缩小 ---

//可读可写型
int e = 30;

//只读型
const int &f = e;     √ √ √

---

! 临时变量具有常属性 !

类型转换，并不会改变变量类型，中间都会产生一个临时变量！！

//临时变量具有常属性 --- 相当于被const修饰了
int ii = 1;
//发生 -- 隐式转换 -- 
double dd = ii;        //隐式类型转换是语法允许的

--------------------------

//报错   权限被放大
double &rdd = ii;      // × × × 权限被放大了
//权限的平移
const double &rdd = ii;

---

• ---- 使用反例----

void func1(int  n)
{}
void func2(int& n)
{}
void func3(const int& n)
{}

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

	func2(a);

	//权限被放大   -- 报错 --
	func2(b);
	//权限被放大   -- 报错 --
	func2(30);
	
	double d = 2.22;
	//权限被放大   -- 报错 --
	func2(d);
	//语法允许
	func3(d);
	return 0;
}

总结：

1. 权限只能缩小，不能放大，放大就会报错。
2. 权限放大和缩小只针对引用和指针。
3. 临时变量具有常属性。
4. const 引用具有非常强的接受度。
5. 使用引用传参，函数内不改变参数，尽量使用 const 引用传参

---

四、 引用的使用场景

4.1 做参数

引用做形式参数，就避免使用了指针，改变函数内的形参就是改变了外面传入的实参。

//做参数
//这样 直接改变形参就是改变了外面的实参
void Swap(int& left, int& right) 
{
  int temp = left;
  left = right;
  right = temp;
}

4.2 做返回值(传引用返回)

传引用返回： 含义为返回 返回对象的别名。

传值返回：生成一个返回对象拷贝作为函数调用的返回值。 

• 函数返回值（如果有返回值）在被调用完毕后是不会随着栈帧的销毁而消失的。因为返回值在函数栈帧被销毁之前被存放在某个寄存器中，而寄存器是独立于内存和系统之外的硬件，上一个函数直接取得该寄存器中的值即能得到返回值。

我们下面使用传引用返回，即 int& 作为返回类型，返回的是 n 的别名。

我们来画一下函数栈帧图，并在下图直接解释一下为什么程序是错误的：

那这样呢？我们使用 int & ret 接受。

 这里为什么 ret 第一次打印的值是正确的呢？第二次就不正确了呢？

• 第一次调用：这里 Count 函数将 n 的别名返回后给 ret 接受，ret 引用的是一块被回收的空间，但是其中的值还没有被置为随机值，然后调用 cout 函数，ret 重新访问 n 地址处的值，将值放传入了 cout 函数中，此时 ret 将正确的值传入了 cout ，cout开始建立栈帧并打印传入的值，随后栈帧销毁。
• 第二次调用：ret 继续访问以前 n 地址处的值，因为栈帧被 cout 使用过，(相当于被保洁阿姨进行了打扫),所以取出了 n 地址处的随机值传入 cout ，所以控制台上输出的是随机值。
• 下面这段程序就能再次体现传引用返回已经上面出现的问题

• 这篇本章可以详细的解释上面的原因，附上好文：
• 函数引用返回底层分析 —— 栈帧创建与销毁

正确使用方式： 

  !!!  总结  !!!

•  出了函数作用域，返回对象就销毁了，那么一定不能用传引用返回，一定要使用传值返回！
• 避免使用局部变量做引用返回！！！

传引用返回的真正使用场景：

如果传引用返回的值是已经开辟好的，栈帧销毁了也不会影响的，那我们可以使用传引用返回，这样既可以访问到该地址处的值，同样也可以直接对其进行修改。

例如下面，直接修改返回值。

---

五、传值、传引用效率比较

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

5.1 函数传值与传引用

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

  // 分别计算两个函数运行结束后的时间

  cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
  cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl; 
}

不难发现，引用传参在处理大型数据时，较大数据有节省时间的优势！ 

5.2 值与引用作为函数返回值

#include <time.h>
struct A { int a[10000]; };
//全局变量A
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;
}

六、 引用和指针的区别

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

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