Quartz 4

引用与指针

11 min read

C++ 引用与指针详解

在 C++ 中，指针 (Pointer) 和 引用 (Reference) 都提供了间接访问其他变量的能力。然而，它们在底层概念、语法和使用方式上有着本质的区别。理解这些区别对于编写安全、高效的 C++ 代码至关重要。

一个简单的比喻：

  • 指针 就像一张写有朋友家庭住址的便签。你可以通过这张便签找到朋友的家，也可以擦掉这个地址，写上另一个地址，或者这张便签上什么都不写（空指针）。
  • 引用 就像一个人的“绰号”或“别名”。绰号就是这个人本身，它不是一个独立的东西，一旦起了绰号，它就一直代表这个人，不能再用作别人的绰号。

一、 指针 (Pointer)

1. 什么是指针？

指针是一个变量，其值为另一个变量的内存地址。通过这个地址，我们可以间接地读取或修改那个变量的值。

2. 语法和操作

  • 声明指针: 类型* 指针名; 例如: int* ptr;
  • 获取地址: 使用取地址符 &。 例如: ptr = &myVar;
  • 解引用: 使用解引用符 * 来访问指针所指向地址上的值。例如: *ptr = 20;

3. 核心特性

  • 可以为空 (Nullable): 指针可以不指向任何对象，即可以被赋值为 nullptr (或 NULL)。在使用前必须检查其是否为空，否则解引用空指针会导致程序崩溃。
  • 可以被重新赋值: 一个指针可以在其生命周期内指向不同的对象。
  • 拥有自己的内存空间: 指针变量本身也占用内存空间（通常是 4 或 8 字节，取决于系统架构），用来存储地址值。
  • 支持指针算术: 可以对指针进行加减运算，使其指向相邻的内存单元，这在处理数组时非常有用。

4. 代码示例

#include <iostream>
 
int main() {
    int a = 10;
    int b = 20;
 
    // 1. 声明一个整型指针
    int* ptr;
 
    // 2. 将指针指向变量 a 的地址
    ptr = &a;
    std::cout << "ptr 指向 a..." << std::endl;
    std::cout << "a 的地址: " << &a << std::endl;
    std::cout << "ptr 存储的地址: " << ptr << std::endl;
    std::cout << "通过 ptr 访问 a 的值: " << *ptr << std::endl;
 
    // 3. 通过指针修改 a 的值
    *ptr = 15;
    std::cout << "通过 ptr 修改后, a 的值: " << a << std::endl;
 
    // 4. 重新赋值，让指针指向变量 b
    ptr = &b;
    std::cout << "\nptr 重新指向 b..." << std::endl;
    std::cout << "b 的地址: " << &b << std::endl;
    std::cout << "ptr 存储的新地址: " << ptr << std::endl;
    std::cout << "通过 ptr 访问 b 的值: " << *ptr << std::endl;
 
    // 5. 空指针
    ptr = nullptr;
    std::cout << "\nptr 被设置为空指针。" << std::endl;
    // if (ptr != nullptr) { *ptr = 30; } // 在使用前必须检查
 
    return 0;
}

二、 引用 (Reference)

1. 什么是引用？

引用是一个已存在变量的别名。它不是一个新对象，也没有自己的内存地址。它仅仅是原变量的另一个名字。对引用的任何操作都等同于对原变量的操作。

2. 语法和操作

  • 声明引用: 类型& 引用名 = 变量名; 例如: int& ref = myVar;

3. 核心特性

  • 必须在声明时初始化: 引用必须在创建时就绑定到一个具体的变量上，不能只声明不初始化。
  • 不能为空 (Not Nullable): 引用不能像指针一样为空，它必须始终指向一个有效的对象。这使得使用引用比使用指针更安全。
  • 不能被重新赋值: 引用一旦被初始化，就不能再“引用”到另一个对象。它将终生绑定到最初的那个变量上。对引用赋值，实际上是修改它所引用的原始变量的值。
  • 不拥有自己的内存空间: 引用与其引用的变量共享同一块内存地址。sizeof(ref) 返回的是原始变量的大小。

4. 代码示例

#include <iostream>
 
int main() {
    int x = 100;
 
    // 1. 声明一个引用并初始化，它是 x 的别名
    int& ref = x;
 
    std::cout << "x 的值: " << x << std::endl;
    std::cout << "ref 的值: " << ref << std::endl;
 
    std::cout << "\nx 的地址: " << &x << std::endl;
    std::cout << "ref 的地址: " << &ref << std::endl; // 注意：地址与 x 完全相同
 
    // 2. 通过引用修改值
    ref = 200;
    std::cout << "\n通过 ref 修改后, x 的值: " << x << std::endl;
    std::cout << "ref 的值也变为: " << ref << std::endl;
 
    // 3. 尝试将引用“重新赋值”给另一个变量
    int y = 300;
    ref = y; // 这不是让 ref 引用 y！
             // 而是将 y 的值 (300) 赋给 ref 所引用的变量 (x)
             
    std::cout << "\n执行 ref = y; 之后..." << std::endl;
    std::cout << "x 的值: " << x << std::endl;   // x 的值变成了 300
    std::cout << "y 的值: " << y << std::endl;   // y 的值不变
    std::cout << "ref 的值: " << ref << std::endl; // ref 仍然是 x 的别名，所以值也是 300
    std::cout << "ref 的地址仍然是 x 的地址: " << &ref << std::endl;
 
    return 0;
}

三、 核心区别对比

特性指针 (Pointer)引用 (Reference)
初始化可以在任何时候初始化，也可以不初始化。必须在声明时初始化。
空值可以是 nullptr，表示不指向任何对象。不能为空，必须引用一个有效的对象。
可重赋值性可以在生命周期内指向不同的对象。一旦初始化，不能再引用其他对象。
内存地址拥有自己独立的内存地址和空间。与其引用的变量共享同一内存地址。
**sizeof** 运算sizeof(ptr) 返回指针本身的大小（如4或8字节）。sizeof(ref) 返回其引用的原始变量的大小。
语法使用 * 和 & 进行操作，语法相对复杂。像普通变量一样使用，语法更简洁、自然。

四、 使用场景

推荐使用引用的场景：

  1. 函数参数传递 (Pass-by-Reference):
  • 目的：避免大型对象拷贝带来的性能开销，并允许函数修改调用者传入的变量。
  • 优点：比指针更安全（无需检查空值）且语法更清晰。
// 使用引用避免了 Person 对象的复制
void printPersonInfo(const Person& person); // const 保证函数不会修改对象
void increaseAge(Person& person); // 非 const 允许函数修改对象
  1. 范围 **for** 循环 (Range-based for loop):
  • 目的：修改容器中的元素，或避免复制元素。
std::vector<int> nums = {1, 2, 3};
// 使用引用&，可以直接修改 vector 中的元素
for (int& num : nums) {
    num *= 2;
}
  1. 函数返回值 (需谨慎):
  • 目的：避免返回大型对象的拷贝。
  • 警告：绝对不能返回对函数内部局部变量的引用，因为函数返回后局部变量被销毁，引用会变成“悬垂引用”，导致未定义行为。
// 错误示例：返回局部变量的引用
int& badFunction() {
    int local = 10;
    return local; // 危险！local 在函数结束后销毁
}

推荐使用指针的场景：

  1. 表示“可能不存在”的对象:
  • 目的：当一个变量可能指向一个对象，也可能什么都不指向时，使用指针并将其设为 nullptr 是最直接的表达方式。
  • 例子：链表中的 next 节点，树中的子节点，它们可能存在也可能不存在（为 nullptr）。
struct Node {
    int data;
    Node* next; // 可能没有下一个节点，所以用指针
};
  1. 动态内存管理:
  • 目的：在堆 (Heap) 上手动创建和销毁对象。new 操作符返回的就是一个指向新分配内存的指针。
int* dynamicArray = new int[100];
// ... 使用数组 ...
delete[] dynamicArray; // 必须手动释放内存

现代 C++ 建议: 优先使用智能指针 (std::unique_ptr, std::shared_ptr) 来自动管理动态内存，以避免内存泄漏。

  1. 与 C 语言库或底层 API 交互:
  • 很多 C 语言风格的 API 都是通过指针来操作数据的，与它们交互时必须使用指针。

总结

“能用引用就用引用，不得已才用指针。”

这是一个广为流传的 C++ 编程准则。

  • 引用更安全、更易用。当你确定需要一个变量的别名，并且这个别名在初始化后不会改变指向时，引用是首选。
  • 指针更灵活、更强大，但也更危险。当你需要处理“可能为空”的情况、动态内存分配或需要重新指向不同对象时，就必须使用指针。

Graph View