指针与引用的本质区别
面试考点
这是 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 引用可以延长临时对象生命周期,但只限于直接绑定
- 引用没有"空"的概念,所以比指针更安全
- 指针算术在数组遍历中有用,引用不支持
总结
指针和引用的根本区别:指针是独立变量,存储地址,可以为空、可以重新指向;引用是别名,必须初始化、不能为空、不能重新绑定。底层实现上引用通常也是用指针,但语义完全不同。面试中要能说清楚这些区别,并给出使用建议:优先用引用(更安全、更简洁),在需要空值或重新指向时用指针。