C++ 引用

什么是引用

引用变量是一个别名，也就是说，它是某个已存在变量的另一个名字一旦把引用初始化为某个变量，就可以使用该引用名称或变量名称来指向变量引用必须在定义时初始化，并且一旦绑定到一个变量后，就不能再绑定到其他变量

1
2


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

解释：

int &ref 表示 ref 是一个 int 类型的引用
ref 是 a 的别名，对 ref 的操作会直接作用于 a

引用与指针

引用很容易与指针混淆，它们之间有三个主要的不同：

不存在空引用，引用必须连接到一块合法的内存。
一旦引用被初始化为一个对象，就不能被指向到另一个对象。指针可以在任何时候指向到另一个对象。
引用必须在创建时被初始化。指针可以在任何时间被初始化。
引用的对象必须是一个变量，而指针必须是一个地址。

特性	引用	指针
定义与初始化	必须初始化，且不能为 `null`。	可以不初始化，可以在后续代码中指向其他对象，可以为 `null`。
语法	使用 `&` 声明，例如：`int &ref = a;`	使用 `` 声明，例如：`int ptr = &a;`
重新绑定	不能重新绑定，一旦初始化后始终引用同一个对象。	可以重新指向其他对象，例如：`ptr = &b;`
空值（Nullability）	不能为 `null`，必须绑定到有效的对象。	可以为 `null`，表示不指向任何对象。
内存占用	不占用额外内存（编译器通常将其优化为直接操作所引用的对象）。	占用额外内存（存储地址，通常是一个机器字长，如4字节或8字节）。
访问方式	直接使用，无需解引用操作符，例如：`ref = 10;`	需要使用 `` 解引用操作符访问或修改所指向的对象，例如：`ptr = 10;`
多级间接访问	不支持多级间接访问（不能有引用的引用）。	支持多级间接访问（如指针的指针：`int **pptr;`）。
函数参数传递	常用于函数参数传递，语法简洁，例如：`void func(int &x) { x = 10; }`	也可以用于函数参数传递，但需要使用解引用操作符，例如：`void func(int x) { x = 10; }`
数组与引用	不能直接创建引用数组，但可以创建数组的引用，例如：`int (&ref)[10] = arr;`	可以创建指针数组，也可以创建指向数组的指针，例如：`int *ptrArr[10];`
安全性	更安全，不能为 `null`，且语法更直观。	更灵活，但容易出错（如空指针、野指针等）。
底层实现	通常通过指针实现，但编译器会优化为直接操作所引用的对象。	直接存储目标对象的内存地址。

创建引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


#include <iostream>
 
using namespace std;
 
int main ()
{
   // 声明简单的变量
   int    i;
   double d;
 
   // 声明引用变量
   int&    r = i;
   double& s = d;
   
   i = 5;
   cout << "Value of i : " << i << endl;
   cout << "Value of i reference : " << r  << endl;
 
   d = 11.7;
   cout << "Value of d : " << d << endl;
   cout << "Value of d reference : " << s  << endl;
   
   return 0;
}

输出

1
2
3
4


Value of i : 5
Value of i reference : 5
Value of d : 11.7
Value of d reference : 11.7

引用的一些用法

引用作为函数参数

直接交换是交换的形参，用引用就可以交换实值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


#include <iostream>
using namespace std;
 
// 函数声明
void swap(int& x, int& y);
 
int main ()
{
   // 局部变量声明
   int a = 100;
   int b = 200;
   cout << "交换前，a 的值：" << a << endl;
   cout << "交换前，b 的值：" << b << endl;
   /* 调用函数来交换值 */
   swap(a, b);
   cout << "交换后，a 的值：" << a << endl;
   cout << "交换后，b 的值：" << b << endl;
   return 0;
}
 
// 函数定义
void swap(int& x, int& y)
{
   int temp;
   temp = x; /* 保存地址 x 的值 */
   x = y;    /* 把 y 赋值给 x */
   y = temp; /* 把 x 赋值给 y  */
   return;
}

输出

1
2
3
4


交换前，a 的值： 100
交换前，b 的值： 200
交换后，a 的值： 200
交换后，b 的值： 100

引用作为函数返回值

通过使用引用来替代指针，会使 C++ 程序更容易阅读和维护。C++ 函数可以返回一个引用，方式与返回一个指针类似

当函数返回一个引用时，则返回一个指向返回值的隐式指针。这样，函数就可以放在赋值语句的左边

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


#include <iostream>
 
using namespace std;
 
double vals[] = {10.1, 12.6, 33.1, 24.1, 50.0};
 
double& setValues(int i) {  
   double& ref = vals[i];    
   return ref;   // 返回第 i 个元素的引用，ref 是一个引用变量，ref 引用 vals[i]
}
 
// 要调用上面定义函数的主函数
int main ()
{
   cout << "改变前的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
   setValues(1) = 20.23; // 改变第 2 个元素
   setValues(3) = 70.8;  // 改变第 4 个元素
 
   cout << "改变后的值" << endl;
   for ( int i = 0; i < 5; i++ )
   {
       cout << "vals[" << i << "] = ";
       cout << vals[i] << endl;
   }
   return 0;
}

输出

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


改变前的值
vals[0] = 10.1
vals[1] = 12.6
vals[2] = 33.1
vals[3] = 24.1
vals[4] = 50
改变后的值
vals[0] = 10.1
vals[1] = 20.23
vals[2] = 33.1
vals[3] = 70.8
vals[4] = 50

当返回一个引用时，要注意被引用的对象不能超出作用域。所以返回一个对局部变量的引用是不合法的，但是，可以返回一个对静态变量的引用