C++ 引用 - 引用的特点|在优化程序上的作用

最新推荐文章于 2024-06-26 20:17:52 发布

BuiderCodes

最新推荐文章于 2024-06-26 20:17:52 发布

阅读量748

点赞数 27

文章标签： c++ 开发语言

本文链接：https://blog.csdn.net/BuiderCodes/article/details/139614158

版权

引用是C++ 的一个别名机制，所谓别名，就是同一块内存共用多个名字，每个名字都指的是这片空间，通过这些别名都能访问到同样的一块空间。

就像鲁迅和周树人是同一个人。

——鲁迅

一、引用的基本用法

int a = 10;
int& ref = a; // ref 是 a 的引用

ref = 20; // 这也会改变 a 的值
std::cout << a; // 输出 20

需要注意的是，这里定义的引用变量ref并不会在内存上开辟新的空间，而是给a对应的那片空间取了一个新的名字，现在通过ref也能访问到那片空间了。

`&`符号我们不会陌生，在之前他的名字是取地址符，在C++中它还有新的作用：定义引用。

在使用中，主要有这两个区别和联系：

1.定义引用时：`&`在类型之后，表示该变量是引用。

int& ref = a;

2. 获取地址时：`&`在变量前边，表示获取该变量的地址。

int* ptr = &a;

二、引用的特点

必须初始化：引用在声明时必须进行初始化。
```
int& a; //错误的！！
```

不可重新绑定：初始化后不能再指向其他变量。

int a = 0;
int b = 0;

int& ref = a;
int& ref = b; //错误的！！

类型一致：引用的类型必须与其引用的变量类型一致。
```
int a = 0;
float& b = a; //错误的！！
```

权限不能放大：在引用的过程中，权限可以平移，缩小，但不能放大

const int a = 0;
int& b = a; //权限的放大
const int& b = a; //权限的平移
 
int c = 0;
const int& d = c; //权限的缩小

多个别名：一个变量可以有多个引用。
```
int a = 0;
int& ref1 = a;
int& ref2 = a;
```
没有独立空间：在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间（在底层实现上实际是有空间的，因为引用是按照指针方式来实现的）
```
int a = 0;
int& ref = a;
```

没有“二级引用”、没有“空引用”

int a = 0;
int& ref1 = NULL; //错误的！！
int&& ref2 = a; //错误的！！

三、引用的作用

以前的交换函数我们只能通过传递参数的指针来实现，而有了引用，我们可以通过给要交换的参数取别名的方式来实现：

#include<iostream>
using namespace std;

void swap(int& a, int& b)
{
	int t = a;
	a = b;
	b = t;
}

int main()
{
	int i = 6, j = 2;
	swap(i, j);

	cout << i << endl;
	cout << j << endl;
	return 0;
}

i，j是实参，a，b是形参，且由于我们在形参类型后加了`&`，也就是说定义了a，b分别是i，j的别名，现在a，b分别代表i，j的那片空间了，所以在交换函数中我们可以通过直接交换a，b的值来交换i，j的值，从而实现了实参传给形参，形参的改变可以改变实参的功能。

再来看一个顺序表的例子，这是没有引用前我们的写法：

struct SeqList
{
	int a[100];
	int size;
	int capacity;
};

//C实现的写法
int SLFind(struct SeqList* p, int i)
{
	// ... ...
	return p->a[i];
}

void SLModify(struct SeqList* p, int i, int x)
{
	p->a[i] = x;
}

int main()
{
	struct SeqList s;
	// ... ...
	SLFind(&s, 0);

	SLModify(&s, 0, 1);

}

要实现查找和修改这两个功能，我们分别需要`SLFind`和`SLModify` 两个函数来实现，而且需要传递顺序表结构的指针才能进行对值的修改。、

而有了引用，首先我们可以优化参数的传递：改为定义引用来接收实参，从而达到修改形参实现修改实参的功能。其次我们还可以优化程序，用一个函数就能实现修改与查找的功能：

struct SeqList
{
	int a[100];
	int size;
	int capacity;
};

//CPP实现的接口
int& SLFind(struct SeqList& p, int i)
{
	// ... ...
	return p.a[i]; // 返回引用，允许对顺序表元素进行修改
}

int main()
{
	struct SeqList s;
	// ... ...
	SLFind(s, 0) = 1;  //Modify
	cout << SLFind(s, 0) << endl;  //Find
}

在上面这段代码中，我们发现引用也可以作为返回值，但其实这一作用在某些情况下是不安全的，可以看下面这个例子：

int& add(int a, int b)
{
	int n = a + b;
	return n; //返回n的别名
}

int main()
{
	int rst = add(1, 2);
	cout << rst << endl;

	return 0;
}

这段代码的输出值是多少？是3吗？

这段代码其实存在一个严重安全的问题：add函数返回的是局部变量 n 的引用。在 add 函数执行完毕后，局部变量 n 的生命周期结束，其内存被释放，返回的引用将指向一个已经释放的内存位置。这就像指针里我们提到的野指针。所以，具体输出的值取决于编译器，如果内存释放后编译器将这部分内存置为随机值，那么输出的值就是一个随机值。

如果改成这样呢？

int& add(int a, int b)
{
	int n = a + b;
	return n; //返回n的别名
}

int main()
{
	int& rst = add(1, 2);
	cout << rst << endl;
    cout << rst << endl;

	return 0;
}

在上一段代码是将 n 的值拷贝给 rst，输出的 rst 取决于存放 n 的那片内存有没有被置为随机值。

而现在变成了 rst 是 n 别名，两次打印 rst 的值可能是不同的，原因：

接下来调用 cout 函数，新建立的栈帧在原来的 add 的那片空间中

由于调用前 n 的值首先被压入栈帧，所以第一次能够成功读取到 n 的值，但第二次输出的值就是不确定的了，因为 cout 可能会覆盖到存放 n 的值的那片空间（这取决于cout所需要的栈帧空间），如果覆盖到了，那么第二次调用 cout 打印 n 的值就是随机数了。

综上所述，引用的作用有：

函数参数传递：避免拷贝，提高效率。尤其是对于传递较大的结构体时，效率的提升是显著的；
实现实参传给形参，形参的改变可以改变实参；
引用作为返回值：通过返回引用，可以在函数外部修改函数内部的变量。同时避免返回值的拷贝，从而提高性能，尤其是在返回大型对象时效果显著。

注意，引用必须绑定有效对象：函数返回引用时，必须确保返回的引用绑定到一个有效的对象。避免返回局部变量的引用，因为局部变量在函数结束时会被销毁。