C++————引用
1. 引用的概念和定义
引用不是新定义⼀个变量，而是给已存在变量取了⼀个别名，编译器不会为引用变量开辟内存空间。
引用是一个已经存在的变量的别名，就像一个人有一个小名或外号一般，它并不占用内存空间，且在声明时必须初始化。一旦引用与某个变量绑定后，就不能再绑定到其他变量。
类型& 引用别名=引用对象;
#include<iostream>
using namespace std;
int main()
{
int a = 0;
//引⽤：b和c是a的别名
int& b = a;
int& c = a;
//也可以给别名b取别名，d相当于还是a的别名
int& d = b;
++d;
//这⾥取地址我们看到是⼀样的
cout << &a << endl;
cout << &b << endl;
cout << &c << endl;
cout << &d << endl;
return 0;
}虽然C++ 中引用和指针都可以用来间接访问变量，但使用 引用 主要是为了替代 指针 以实现更简洁、更安全的代码。
下面给出一个示例：
这是一个链表的尾插代码：
//尾插
void SLTPushBack(SLTNode** pphead, SLTDataType x)
{
SLTNode* newnode = SLTBuyNode(x);
//链表为空，phead直接指向newnode结点
if (*pphead == NULL)
{
*pphead = newnode;
}
else {
//链表不为空，找尾结点，将尾结点和新节点连接起来
SLTNode* ptail = *pphead;
while (ptail->next)//等价于ptail->next != NULL
{
ptail = ptail->next;
}
//ptail newnode
ptail->next = newnode;
}
}在外面学习到这里时，相信有许多人会对双指针的运用与理解感到头痛，但是使用引用的话就会很好的解决这一问题。
下面使用引用：
void STPush(ST& rs, STDataType x)
{
// 满了， 扩容
if (rs.top == rs.capacity)
{
printf("扩容\n");
int newcapacity = rs.capacity == 0 ? 4 : rs.capacity * 2;
STDataType* tmp = (STDataType*)realloc(rs.a, newcapacity *sizeof(STDataType));
if (tmp == NULL)
{
perror("realloc fail");
return;
}
rs.a = tmp;
rs.capacity = newcapacity;
}
rs.a[rs.top] = x;
rs.top++;
}这充分体现了引用具有更简洁、更安全、更易于理解的优点，但由于使用引用的限制，指针也是不可替代的，下面会讲解。
2. 引用的特征
1. 必须初始化
引用在声明时必须进行初始化，并且一旦绑定到某个变量后，引用就不能再指向其他对象。引用不能为空。
int a = 10;
int& ref = a; // 引用必须在声明时初始化，且 ref 永远指向 a2. 引用一旦引用一个实体，再不能引用其他实体
一旦引用与某个变量绑定，它就不能再绑定到其他变量上。引用总是与它初始化时绑定的对象保持一致。
#include <iostream>
using namespace std;
int main() {
int a = 10;
int b = 20;
int& ref = a; // ref 引用到 a
cout << "ref: " << ref << endl; // 输出 10
// 尝试改变引用绑定的对象
ref = b; // 这不会使 ref 绑定到 b，而是将 a 的值修改为 b 的值
cout << "a: " << a << endl; // 输出 20，a 的值被修改为 20
cout << "b: " << b << endl; // 输出 20，b 的值保持不变
// 引用无法直接改变绑定的对象
// ref = &b; // 错误：ref 是引用，不能指向不同的对象
return 0;
}3. 一个变量可以有多个引用
一个变量可以有多个引用，所有这些引用都会指向相同的变量，因此对任何一个引用的修改都会影响到原始变量。多个引用共同作用于同一个对象，彼此之间是完全相等的。
#include <iostream>
using namespace std;
int main() {
int a = 10;
int& ref1 = a; // ref1 引用 a
int& ref2 = a; // ref2 也引用 a
cout << "a: " << a << endl; // 输出 a: 10
cout << "ref1: " << ref1 << endl; // 输出 ref1: 10
cout << "ref2: " << ref2 << endl; // 输出 ref2: 10
// 修改其中一个引用的值
ref1 = 20;
cout << "a after ref1 modification: " << a << endl; // 输出 a: 20
cout << "ref1 after modification: " << ref1 << endl; // 输出 ref1: 20
cout << "ref2 after ref1 modification: " << ref2 << endl; // 输出 ref2: 20
return 0;
}3. 引用的使用
1. 引用作为函数参数
引用作为函数参数可以避免传递数据的副本，提高程序的效率，尤其是传递大型对象时。此外，使用引用参数还可以在函数内修改原始数据。
示例：
#include <iostream>
using namespace std;
// 引用作为函数参数
void modifyValue(int& x) {
x = 100; // 修改传入的值
}
int main() {
int a = 10;
cout << "Before: " << a << endl;
modifyValue(a); // 传递引用，修改 a 的值
cout << "After: " << a << endl; // 输出 100，因为 a 被修改了
return 0;
}
2. 引用作为函数参数
函数可以返回引用，使得调用者可以修改函数内部的变量。
#include <iostream>
using namespace std;
int globalVar = 10;
// 引用作为函数返回值
int& getGlobalVar() {
return globalVar; // 返回全局变量的引用
}
int main() {
cout << "Before: " << globalVar << endl;
getGlobalVar() = 20; // 修改全局变量的值
cout << "After: " << globalVar << endl; // 输出 20
return 0;
}引用作为函数参数和引用作为函数参数的对比：
如上面的右侧代码，使用引用作为函数参数，但出现了报错，是因为传值返回并不是将值返回，而是返回了一个拷贝做为临时对象，临时对象具有常性，是一个右值，不能修改。
左侧的传引用返回，返回的是它的别名，相当于可以在栈里修改这个对象。这就是传引用返回的意义。
需要注意的是，返回局部变量的引用是危险的，因为局部变量在函数返回后会被销毁，引用将变为悬挂引用。
当func函数结束时，想要返回ret的别名，但此时func栈帧已经销毁了，找不到ret，从而造成野引用。
4. const引用
在C++中，const 引用是一种引用类型，限制了对被引用对象的修改。这意味着你可以通过引用访问对象，但不能修改该对象的值。const 引用的主要用途是保护数据不被修改，同时允许高效地传递较大对象而不进行复制。
1. 常量引用作为函数参数
常量引用常用于传递函数参数时避免对象的复制，同时确保函数不能修改对象。特别是对于大对象（如大型结构体或类），使用常量引用可以提高效率。
示例：
#include <iostream>
using namespace std;
void printValue(const int& x) {
cout << "Value: " << x << endl; // 只能读取 x，不能修改它
}
int main() {
int a = 5;
printValue(a); // 传递常量引用
// a = 10; // 如果 printValue 修改了 a，它会报错（因为 x 是常量引用）
return 0;
}2. 常量引用与临时对象
常量引用不仅可以绑定到变量，也可以绑定到临时对象（如临时计算结果）。这使得常量引用在函数调用时非常有用，特别是当我们不希望传递副本的同时又不想修改传入的对象。
示例：
#include <iostream>
using namespace std;
void printValue(const int& x) {
cout << "Value: " << x << endl;
}
int main() {
printValue(10); // 10是一个临时对象，可以通过const引用传递
return 0;
}
在上述代码中，10是一个临时的整数对象，const int& x可以接受这个临时对象作为参数，而如果使用普通引用（非const），则不能传递临时对象。
3. 常量引用与常量数据
如果引用绑定到一个常量数据（如常量变量），则引用本身也会成为常量引用。
示例：
#include <iostream>
using namespace std;
int main() {
const int a = 100; // 常量变量
const int& ref = a; // 常量引用，无法修改 a
cout << "a = " << a << endl; // 输出 100
// ref = 200; // 错误，ref 是常量引用，无法修改它绑定的对象
return 0;
}