指针与引用的本质区别 ​

面试考点 ​

这是 C++ 面试中几乎必问的基础题。面试官希望你能从语法、语义、底层实现等多个角度说清楚指针和引用的区别,而不是只列出表面差异。

核心区别 ​

指针是一个独立的变量,存储的是另一个变量的内存地址。引用是已有变量的别名,本质上和原变量是同一个东西。

cpp
#include <iostream>

// ============================
// 基本区别演示
// ============================

void basic_demo() {
    int x = 10;

    // 指针:独立变量,存储 x 的地址
    int* ptr = &x;

    // 引用:x 的别名,和 x 是同一个东西
    int& ref = x;

    // 修改值
    *ptr = 20;        // 通过指针修改,需要解引用
    std::cout << "x = " << x << std::endl;  // 20

    ref = 30;          // 通过引用修改,直接使用
    std::cout << "x = " << x << std::endl;  // 30

    // 地址
    std::cout << "&x   = " << &x << std::endl;
    std::cout << "ptr  = " << ptr << std::endl;   // 和 &x 相同
    std::cout << "&ref = " << &ref << std::endl;   // 和 &x 相同
    std::cout << "&ptr = " << &ptr << std::endl;   // ptr 自己的地址,和 &x 不同
}

// ============================
// 重新绑定
// ============================

void rebind_demo() {
    int a = 10, b = 20;

    // 指针可以重新指向
    int* p = &a;
    p = &b;          // OK:p 现在指向 b
    std::cout << "*p = " << *p << std::endl;  // 20

    // 引用不能重新绑定
    int& r = a;
    r = b;            // 这不是重新绑定!这是把 b 的值赋给 a
    std::cout << "a = " << a << std::endl;    // 20(a 被修改了)
    std::cout << "&r == &a: " << (&r == &a) << std::endl;  // 1(r 仍然是 a 的别名)
}

// ============================
// 空值
// ============================

void null_demo() {
    // 指针可以为空
    int* p = nullptr;
    // *p;  // 解引用空指针是未定义行为

    // 引用不能为空,必须在声明时绑定到有效对象
    // int& r;          // 编译错误:引用必须初始化
    // int& r = *p;     // 未定义行为

    int x = 42;
    int& r = x;         // OK:绑定到 x
}

// ============================
// sizeof
// ============================

void sizeof_demo() {
    int x = 42;
    int* p = &x;
    int& r = x;

    // 指针的 sizeof 是指针本身的大小(32 位系统 4 字节,64 位系统 8 字节)
    std::cout << "sizeof(int*) = " << sizeof(p) << std::endl;

    // 引用的 sizeof 是被引用对象的大小
    std::cout << "sizeof(int&) = " << sizeof(r) << std::endl;  // 和 sizeof(int) 相同

    double d = 3.14;
    double& dr = d;
    std::cout << "sizeof(double&) = " << sizeof(dr) << std::endl;  // 8
}

// ============================
// 函数参数传递
// ============================

// 指针参数:调用者需要传地址
void swap_ptr(int* a, int* b) {
    int temp = *a;
    *a = *b;
    *b = temp;
}

// 引用参数:调用者直接传变量
void swap_ref(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

void param_demo() {
    int x = 10, y = 20;

    swap_ptr(&x, &y);  // 传地址
    std::cout << "指针交换后: x=" << x << ", y=" << y << std::endl;

    swap_ref(x, y);     // 直接传变量
    std::cout << "引用交换后: x=" << x << ", y=" << y << std::endl;
}

int main() {
    std::cout << "=== 基本区别 ===" << std::endl;
    basic_demo();

    std::cout << "\n=== 重新绑定 ===" << std::endl;
    rebind_demo();

    std::cout << "\n=== sizeof ===" << std::endl;
    sizeof_demo();

    std::cout << "\n=== 函数参数 ===" << std::endl;
    param_demo();

    return 0;
}

对比表 ​

特性指针引用
本质存储地址的独立变量已有变量的别名
初始化可以不初始化必须在声明时初始化
空值可以为 nullptr不能为空
重新绑定可以指向其他对象不能重新绑定
解引用需要用 * 解引用自动解引用,直接使用
sizeof指针本身的大小被引用对象的大小
多级间接支持指针的指针没有引用的引用
算术运算支持 p++、p+n 等不支持
数组可以有指针数组不能有引用数组
底层实现存储地址通常也用地址实现

常见问题 ​

引用在底层是怎么实现的?

大多数编译器把引用实现为一个隐藏的 const 指针(T* const)。但标准没有规定这一点,编译器也可能直接优化掉引用,让它不占用任何空间。面试中可以说"引用在底层通常用指针实现,但在语义上它是别名"。

什么时候用指针,什么时候用引用?

一般原则:能用引用就用引用,需要"可选"(可能为空)或"可变"(需要重新指向)时用指针。函数参数如果不需要修改,用 const 引用;如果参数可能为空,用指针。

右值引用 && 是引用还是指针?

右值引用是引用的一种,语法上用 && 声明。它可以绑定到临时对象(右值),主要用于移动语义和完美转发。

const 引用可以绑定到临时对象吗?

可以。const int& ref = 42; 是合法的,编译器会延长临时对象的生命周期到引用的作用域结束。

适用场景 ​

  • 用引用:函数参数传递(避免拷贝)、运算符重载、返回值优化
  • 用指针:动态内存管理、可选参数(可能为 nullptr)、数据结构(链表、树)、需要重新指向

注意事项 ​

  • 悬空引用和悬空指针一样危险
  • 不要返回局部变量的引用或指针
  • const 引用可以延长临时对象生命周期,但只限于直接绑定
  • 引用没有"空"的概念,所以比指针更安全
  • 指针算术在数组遍历中有用,引用不支持

总结 ​

指针和引用的根本区别:指针是独立变量,存储地址,可以为空、可以重新指向;引用是别名,必须初始化、不能为空、不能重新绑定。底层实现上引用通常也是用指针,但语义完全不同。面试中要能说清楚这些区别,并给出使用建议:优先用引用(更安全、更简洁),在需要空值或重新指向时用指针。