返回专栏
· 11 分钟阅读

指针与引用(Pointers & References)


1. 什么是指针与引用?

指针(Pointer)和引用(Reference)都可以间接访问某个数据,但它们在语义、使用方式和安全约束上存在明显差异。

1.1 指针(Pointer)

指针是一种保存内存地址的变量。通过指针,可以间接访问该地址对应的对象或内存区域。

例如,C 语言:

int value = 100;
int *ptr = &value;

printf("%d\n", *ptr); // 100

其中:

  • value:普通整型变量,保存整数 100。
  • &value:取地址运算,获取 value 的内存地址。
  • ptr:指针变量,保存 value 的地址。
  • *ptr:解引用操作,访问指针指向的对象。

指针本身也是一个对象,通常占据一定的内存空间,其存储内容是一个地址值。

1.2 引用(Reference)

引用是一种对已有对象的别名(Alias)。通过引用,可以使用另一个名称访问同一个对象。

例如,C++:

int value = 100;
int& ref = value;

ref = 200;

std::cout << value; // 200

其中:

  • value:原始对象。
  • ref:value 的引用。
  • 修改 ref,实际上就是修改 value。

引用并不是创建一个独立的数据副本,而是为已有对象提供另一种访问方式。

1.3 核心区别

对比维度 指针 引用
本质 保存地址的对象 对已有对象的别名或引用关系
是否需要初始化 不一定,取决于语言和使用场景 通常要求初始化
是否允许为空 通常允许空指针 取决于语言,C++ 引用通常不允许为空
是否可以重新指向 通常可以修改指向的地址 C++ 引用不能重新绑定
访问方式 通常需要解引用 通常直接使用
算术运算 C/C++ 中部分指针支持指针运算 通常不支持
生命周期 指针变量与指向对象的生命周期相互独立 引用的有效性依赖被引用对象
安全性 可能产生悬空指针、越界访问等问题 也可能产生悬空引用,具体取决于语言规则

需要注意:不同语言对指针和引用的定义并不完全一致。C++ 的引用、Rust 的引用、Java 的对象引用,在底层实现和语言约束上都有差异。


2. 指针的工作原理

2.1 内存地址与指针变量

计算机内存可以抽象为一系列可寻址的存储单元。变量通常占据一个或多个内存字节,并具有对应的地址。

假设:

int value = 100;
int *ptr = &value;

可以将其抽象为:

value 所在内存:
地址:0x1000
内容:100

ptr 所在内存:
地址:0x2000
内容:0x1000

这里:

  • value 的地址是 0x1000。
  • ptr 自身位于 0x2000。
  • ptr 保存的内容是 0x1000。
  • *ptr 访问的是地址 0x1000 对应的对象。

这说明指针变量本身与它所指向的对象是两个不同的概念。

2.2 取地址与解引用

C/C++ 中最重要的两个指针操作符:

操作符 名称 作用
& 取地址 获取对象的地址
* 解引用 通过指针访问目标对象

示例:

int number = 10;

int *ptr = &number;

*ptr = 20;

printf("%d\n", number); // 20

执行过程:

flowchart TB
    A["创建变量 number"] --> B["number = 10"]
    B --> C["获取 number 的地址"]
    C --> D["指针 ptr 保存该地址"]
    D --> E["通过 *ptr 解引用"]
    E --> F["修改目标对象的值"]
    F --> G["number = 20"]

    style A fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style B fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

2.3 指针的类型

指针具有类型,类型决定了编译器如何理解指针指向的内存,以及如何进行访问和运算。

int number = 10;
int *int_ptr = &number;

double price = 19.9;
double *double_ptr = &price;

int* 与 double* 都是指针类型,但指向的数据类型不同。

指针类型影响:

  1. 解引用时读取或写入的数据类型。
  2. 指针运算时的步长。
  3. 编译器进行的类型检查。
  4. 某些平台和语言中的对齐要求。

例如:

int arr[3] = {10, 20, 30};
int *ptr = arr;

printf("%d\n", *(ptr + 1)); // 20

ptr + 1 并不是简单地将地址增加 1 个字节,而是向后移动一个 int 对象的大小。

如果 sizeof(int) 为 4,那么地址变化通常是 4 个字节。

2.4 指针的多级间接访问

指针可以指向另一个指针,从而形成多级指针。

int value = 100;

int *ptr = &value;
int **pptr = &ptr;

printf("%d\n", **pptr); // 100

其中:

  • ptr 保存 value 的地址。
  • pptr 保存 ptr 的地址。
  • *pptr 得到 ptr。
  • **pptr 得到 value。

多级指针常用于:

  • 动态创建二维数据结构。
  • 修改函数内部的指针变量。
  • 操作链表、树等复杂结构。
  • 管理需要间接修改的资源句柄。

3. 引用的工作原理

3.1 引用是对象的别名

C++ 中,引用在定义时必须绑定到一个对象。

int value = 100;
int& ref = value;

ref = 200;

此时 ref 与 value 指向同一个对象的访问关系。通过任意一个名称修改对象,另一个名称观察到的值都会发生变化。

int value = 100;
int& ref = value;

std::cout << value; // 100
std::cout << ref;   // 100

ref = 300;

std::cout << value; // 300

3.2 引用不能重新绑定

这是 C++ 引用与指针的重要区别。

int a = 10;
int b = 20;

int& ref = a;

ref = b;

这段代码并不会让 ref 改为引用 b,而是将 b 的值赋给 a。

执行后:

a == 20;
b == 20;

引用仍然绑定到 a。

如果希望改变指向的对象,应使用指针:

int a = 10;
int b = 20;

int* ptr = &a;
ptr = &b;

此时 ptr 才真正改变了指向。

3.3 引用与指针的语法差异

int value = 10;

// 指针
int* ptr = &value;
*ptr = 20;

// 引用
int& ref = value;
ref = 30;

指针通过解引用访问目标对象,引用则直接使用对象的访问语法。

需要强调:C++ 标准规定了引用的语义,并没有要求引用必须以指针的形式实现。编译器可以根据具体上下文优化引用的实现,不能简单地将引用等同于指针。


4. 不同语言中的指针与引用

指针与引用并不是所有语言都以相同方式提供。理解语言设计差异,是避免跨语言概念混淆的关键。

4.1 C 语言:以指针为核心

C 语言提供明确的指针类型,没有 C++ 意义上的引用类型。

void update(int *ptr) {
    if (ptr != NULL) {
        *ptr = 100;
    }
}

int main() {
    int value = 10;

    update(&value);

    return 0;
}

函数通过指针参数访问调用者的变量,从而实现间接修改。

C 语言指针具有较高的灵活性,但也要求程序员自行管理指针有效性和内存访问边界。

4.2 C++:同时提供指针与引用

C++ 保留了 C 风格指针,并增加了引用类型。

void updateByPointer(int* ptr) {
    if (ptr != nullptr) {
        *ptr = 100;
    }
}

void updateByReference(int& ref) {
    ref = 200;
}

二者都可以修改调用者传入的对象,但表达的约束不同:

  • 指针参数可以为空,也可以在函数内部改变指向。
  • 普通引用参数必须绑定到有效对象,不能通过引用本身重新绑定。

C++ 还提供右值引用,用于移动语义和完美转发:

int&& value = 100;

右值引用与普通左值引用不同,不能将二者混为一谈。

4.3 Rust:通过引用与借用保证内存安全

Rust 将引用机制与所有权系统、借用检查器结合起来。

fn main() {
    let value = 100;
    let reference = &value;

    println!("{}", reference);
}

Rust 中:

  • &T:不可变引用。
  • &mut T:可变引用。
  • 引用受到生命周期规则约束。
  • 编译器在编译阶段检查引用是否可能失效。

Rust 的核心借用规则可以概括为:

  1. 可以同时存在多个不可变引用。
  2. 在同一作用域和时间范围内,不能同时存在可变引用与其他引用。
  3. 引用必须始终指向有效的数据。

例如:

let mut value = 10;

let a = &value;
let b = &value;

println!("{} {}", a, b);

多个不可变引用可以同时存在。

而下面的代码存在冲突:

let mut value = 10;

let a = &value;
let b = &mut value;

println!("{}", a);
println!("{}", b);

不可变借用与可变借用在这里同时存活,违反 Rust 的借用规则,因此无法通过编译。

4.4 Java:对象引用不是 C/C++ 指针

Java 没有向普通应用程序开放 C/C++ 风格的原始指针运算,但对象变量保存的是对象引用。

class User {
    String name;
}

User user = new User();
user.name = "Alice";

User another = user;
another.name = "Bob";

System.out.println(user.name); // Bob

user 和 another 引用同一个对象,因此通过 another 修改对象属性,user 也能观察到变化。

但 Java 对象引用不能进行类似 C/C++ 的地址算术,也不能直接解引用任意内存地址。

此外,Java 方法参数始终按值传递。对于对象参数,传递的是引用值的副本:

void update(User user) {
    user.name = "Bob";
}

方法内部可以通过这个引用值访问并修改原对象,但给形参重新赋值,不会改变调用者变量本身。

4.5 Python:变量绑定与对象引用

Python 的变量可以理解为名称与对象之间的绑定关系。

a = [1, 2, 3]
b = a

b.append(4)

print(a)  # [1, 2, 3, 4]

a 和 b 绑定到同一个列表对象,因此通过 b 修改列表,a 也能观察到修改。

但 Python 不提供普通应用代码可直接操作的原始内存指针。它的对象引用由运行时管理,变量本身并不等同于 C/C++ 的指针变量。

4.6 语言机制对比

语言 指针机制 引用机制 主要特点
C 原生指针 无 C++ 式引用 灵活,需自行保证内存访问安全
C++ 原生指针 左值引用、右值引用 同时支持底层控制与高级抽象
Rust 原始指针 借用引用 生命周期与借用规则提供内存安全约束
Java 不开放原始指针运算 对象引用 引用由运行时管理
Python 不提供常规原始指针 对象引用与名称绑定 动态对象模型,内存由运行时管理
Go 提供指针 无 C++ 式引用类型 支持指针访问,但限制指针算术

5. 指针与引用的内存安全问题

指针和引用都涉及对象的访问有效性。即使语言提供引用语法,也不意味着所有引用操作天然安全。

5.1 空指针(Null Pointer)

空指针表示不指向有效对象的指针。

C:

int *ptr = NULL;

C++:

int* ptr = nullptr;

如果对空指针解引用,行为通常是未定义的,可能导致程序崩溃。

int* ptr = nullptr;

*ptr = 10; // 错误:解引用空指针

空指针常用于表示:

  • 尚未关联对象。
  • 查找操作没有结果。
  • 可选资源不存在。
  • 指针当前不持有有效目标。

C++ 普通引用没有对应的标准空引用语义。若通过错误方式制造无效引用,程序行为不再有可靠保证。

5.2 悬空指针(Dangling Pointer)

悬空指针是指向的对象已经结束生命周期,但指针仍然保留原地址的情况。

int* create() {
    int value = 100;
    return &value;
}

函数返回后,局部变量 value 的生命周期已经结束。返回的指针不再指向一个有效的 int 对象。

使用这种指针会产生未定义行为。

正确的解决思路包括:

  • 返回值而不是局部变量地址。
  • 使用动态分配,并明确管理资源生命周期。
  • 使用智能指针管理动态对象。
  • 让被访问对象的生命周期覆盖指针的使用范围。

5.3 悬空引用(Dangling Reference)

引用同样可能因为被引用对象生命周期结束而失效。

int& create() {
    int value = 100;
    return value;
}