新乡网站开发的公司广西建设职业技术学院教育网站

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 newnodeptail->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 永远指向 a

2. 引用一旦引用一个实体，再不能引用其他实体

一旦引用与某个变量绑定，它就不能再绑定到其他变量上。引用总是与它初始化时绑定的对象保持一致。

#include <iostream>
using namespace std;int main() {int a = 10;int b = 20;int& ref = a;  // ref 引用到 acout << "ref: " << ref << endl;  // 输出 10// 尝试改变引用绑定的对象ref = b;  // 这不会使 ref 绑定到 b，而是将 a 的值修改为 b 的值cout << "a: " << a << endl;  // 输出 20，a 的值被修改为 20cout << "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 引用 aint& ref2 = a;  // ref2 也引用 acout << "a: " << a << endl;     // 输出 a: 10cout << "ref1: " << ref1 << endl; // 输出 ref1: 10cout << "ref2: " << ref2 << endl; // 输出 ref2: 10// 修改其中一个引用的值ref1 = 20;cout << "a after ref1 modification: " << a << endl;     // 输出 a: 20cout << "ref1 after modification: " << ref1 << endl;     // 输出 ref1: 20cout << "ref2 after ref1 modification: " << ref2 << endl; // 输出 ref2: 20return 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;  // 输出 20return 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; // 常量引用，无法修改 acout << "a = " << a << endl;  // 输出 100// ref = 200;  // 错误，ref 是常量引用，无法修改它绑定的对象return 0;
}