有人写了个小程序:往 vector<int> 里塞三个数,把 data() 拿到的指针存起来,准备后面批量处理。中途又 push_back 了第四个,然后拿旧指针去读,屏幕上跳出来 -851542368 614 -851574448——原本应该是 10 20 30。他以为是编译器 bug,重启了两次,值每次都不一样。
这不是 bug。容器扩容的时候,原来的内存被释放了,元素被搬到新地址,旧指针还指着那片已经不归它管的内存。指针只记地址,不记「这个地址上的对象还在不在」。这是 C++ 里最基础、也最容易反复踩的一件事。
这篇要讲清五件事:地址和对象到底什么关系;& 和 * 分别在做什么;空指针与指针算术的边界;引用和指针差在哪、什么时候用哪个;以及悬垂指针为什么不总是立刻崩,反而会「看起来正常」。中间会完整跑一个扩容失效的实验,所有输出都是本机实测。
-std=c++20 -Wall -Wextra 编译运行。地址和垃圾值每次运行都可能不同,文中的值照抄自一次实际运行,不代表固定结果。本机没有 ASan 和 valgrind,涉及「工具能抓到但这里抓不到」的结论会写明。地址是数字,对象才是东西
内存可以想成一条很长的字节数组,每个字节有自己的编号,这个编号就是地址。一个对象占用从某个地址开始的一段连续字节,对象的大小由类型决定。int* p 里的 p 保存的是一个地址,类型 int* 告诉编译器:解引用时读 4 个字节,按有符号整数解释。
三样东西要分开看:指针的值(地址,通常 8 字节)、指针的类型(决定解引用怎么解释内存)、以及被指对象的生命周期(指针完全不携带)。前两样编译器管,第三样只能你自己管。悬垂指针的所有事故,都出在第三样上。
int* 与 char* 解引用时读的字节数和解释方式不同同一条地址,用 char* 读是一个字节,用 int* 读是四个字节,用 double* 读是八个字节。所以指针的类型不是装饰,它决定了「怎么看待这块内存」。把 int* 强转成 float* 再解引用,读出来的是一个完全不同的数,还可能违反严格别名规则,属于未定义行为。
还有一个常见误解:指针的地址和它指向的地址不是一回事。&p 是指针变量自己的地址,类型是 int**;p 是它保存的值,也就是目标对象的地址。调试时把这两个搞混,会白白浪费半天。
& 取地址,* 解引用
两个运算符各管一件事:&x 取出 x 的地址,得到指针;*p 顺着 p 里的地址找到对象,得到对象本身。它们互为逆运算,&*p 等于 p,*&x 等于 x。前提是内置运算符,重载过的 operator& 和 operator* 不保证这条。
引用的绑定也是取地址。看这段能直接跑的程序:
#include <cstdio>
int main() {
int x = 7;
int& r = x; // r 是 x 的别名,不占独立对象
int* p = &x; // p 保存 x 的地址
r += 1; // 通过引用改,x 跟着变
std::printf("x=%d r=%d addr_x=%p p=%p\n", x, r,
static_cast<void*>(&x), static_cast<void*>(p));
return 0;
}
编译运行:
g++ -std=c++20 -Wall -Wextra ref_demo.cpp -o app.exe
.\app.exe
本机输出(地址每次运行会变):
x=8 r=8 addr_x=00000062d19ffbf0 p=00000062d19ffbf0
r 和 x 打印出来都是 8,&x 和 p 打印出来是同一个地址。引用在语言层面是别名,不是独立对象;但在实现上,编译器通常就是拿地址办事。这也解释了为什么引用必须初始化——没有「空引用」这个东西。
空指针用 nullptr 表示,不要用 NULL 或 0。nullptr 有自己的类型 std::nullptr_t,能避免重载解析时和整数混淆。解引用空指针是未定义行为,在前一篇里实测过,本机退出码是 -1073741819(0xC0000005,访问违例)。判断空指针写 if (p != nullptr),别写 if (p) 又忘了 p 可能是野指针——初始化之前的指针不一定是空,它可能是个随机地址。
完整走查:扩容把指针弄丢了
回到开头那个现象,把它写成可复现的程序:
// realloc_demo.cpp
#include <iostream>
#include <vector>
int main() {
std::vector<int> v;
v.reserve(3);
v.push_back(10);
v.push_back(20);
v.push_back(30);
int* old = v.data();
std::cout << "before: size=" << v.size() << " cap=" << v.capacity()
<< " data=" << static_cast<void*>(v.data()) << "\n";
v.push_back(40);
std::cout << "after : size=" << v.size() << " cap=" << v.capacity()
<< " data=" << static_cast<void*>(v.data()) << "\n";
std::cout << "old[0]=" << old[0] << " old[1]=" << old[1]
<< " old[2]=" << old[2] << "\n";
std::vector<int> filler(3, -7);
std::cout << "filler data=" << static_cast<void*>(filler.data()) << "\n";
std::cout << "old[0]=" << old[0] << " old[1]=" << old[1]
<< " old[2]=" << old[2] << "\n";
return 0;
}
编译命令和上一篇一样:
g++ -std=c++20 -Wall -Wextra realloc_demo.cpp -o app.exe
.\app.exe
本机实际输出:
before: size=3 cap=3 data=0x266cd3e6e50
after : size=4 cap=6 data=0x266cd3e7e80
old[0]=-851542368 old[1]=614 old[2]=-851574448
filler data=0x266cd3e6e50
old[0]=-7 old[1]=-7 old[2]=-7
逐行读:reserve(3) 之后容量正好 3,前三次插入没有重新分配;第四次插入时容量不够,libstdc++ 按 2 倍扩到 6,另找一块内存把三个旧元素搬过去,data() 从 0x...e50 变成 0x...e80;old 还指着 0x...e50,那里的对象已经销毁,读到的是三个毫不相干的整数。
最后三行更能说明问题:新建的 filler 正好分配到了 0x...e50,也就是旧数组腾出来的那块。old 现在指向 filler 的元素,读出来是 -7。内存没消失,只是换了主人。旧指针不会「变空」,它会安静地指向别人的数据。
这不只影响指针。迭代器、引用、data() 返回的地址,全都遵循同一条规则:任何可能导致重新分配的操作,都会让之前拿到的东西全部失效。push_back、insert、erase、resize、clear 之后的迭代器都属于这一类。要长时间持有元素地址,可以提前 reserve 到足够容量,或者一开始就用 std::deque/链表/下标。更常见的做法是:别存指针,存下标,用的时候 v[i] 重新拿。
old[0] 的那两行本身就是未定义行为,能打印出数字不代表程序是对的。它没有崩,是因为那块内存还映射在进程里;换个分配器、换个编译器、开个优化,可能就崩,也可能读到别的对象。判断代码对不对,不能看「这次跑出来是什么」。指针算术与数组退化
指针的加减不是按字节算,是按「所指类型的大小」算。int* p 加 1,地址前进 4 字节;double* p 加 1,前进 8 字节。数组下标本质上就是这种算术:arr[i] 等价于 *(arr + i),i 可以是负数,只要落在这个数组范围内。
看一段实测的程序:
#include <cstddef>
#include <cstdio>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
int* p = arr;
std::printf("*(p+2)=%d p[2]=%d\n", *(p + 2), p[2]);
std::printf("sizeof(arr)=%zu sizeof(p)=%zu\n", sizeof(arr), sizeof(p));
int* q = arr + 1;
std::printf("q[-1]=%d q[0]=%d *(q+2)=%d\n", q[-1], q[0], *(q + 2));
return 0;
}
本机输出:
*(p+2)=3 p[2]=3
sizeof(arr)=20 sizeof(p)=8
q[-1]=1 q[0]=2 *(q+2)=4
关键在第二行:sizeof(arr) 是 20,sizeof(p) 是 8。同样一个「东西」,在数组上还保留了长度信息,赋给指针之后就只剩一个地址。这叫数组退化(array-to-pointer decay):数组在大多数表达式里会自动转成指向首元素的指针,长度信息随之丢失。
这个退化在函数参数上尤其坑人。写 void f(int a[5]),看起来传了长度,实际上编译器把它当成 int* a,函数里 sizeof(a) 是 8。C++20 的 std::span 可以把「指针 + 长度」打包成一个参数,或者用模板按引用接收数组 void f(int (&a)[5]),长度就不会丢。更省事的办法是把长度一起传,或者直接用 std::vector。
指针算术有明确的边界:可以指到数组末尾后一个位置(one past the end),这是合法的,用来做循环终止条件;再往后走,即使不解引用,也是未定义行为。别写出 p + n 越界之后还拿去做比较的代码,那种「没崩就行」的写法迟早出事。
引用和指针差在哪
看起来引用就是「自动解引用的指针」,实际约束完全不同。引用是对象的一个别名,必须绑定到已有对象,绑定之后不能改指别人,也没有「引用算术」这种东西。
引用:别名,必须有效
不能为空,不能重绑定,也没有引用算术,写法像普通变量。适合「这个参数必须存在」的场合:void print(const std::string& s)。代价是调用方看不出它会不会被改,也存不进容器(要存得用 std::reference_wrapper)。
指针:地址,可以换目标
可以为空,可以改指向,可以做算术,可以指向数组,也可以指向堆上的对象。适合「可能没有」「需要换目标」「需要遍历」的场合。代价是每次解引用前都该问一句「它还活着吗」。
用哪一句总结:能用引用就用引用,需要表达「可以没有」或者「要换目标」时才用指针。函数参数里 const T& 还能避免拷贝,处理大对象时是默认选择。返回引用要格外小心,返回局部变量的引用和返回悬垂指针是同一种病。
引用的「不能为空」也不是绝对的。std::optional<T> 表达「可能没有值」;把空指针解引用得到的引用,照样是未定义行为,编译器不会因为类型是引用就帮你检查。语言层面的保证是「你必须绑定一个有效对象」,违反它,后果和指针一样。
const 的几种位置
const 的位置决定它修饰谁,读法是从右往左,const 修饰它左边的东西,左边没有就修饰右边。四种常见写法:
| 写法 | 读法 | 能不能改 |
|---|---|---|
const int* p | 指向 const int 的指针 | 不能通过 p 改目标;p 可以改指向 |
int const* p | 同上,写法等价 | 同上 |
int* const p | const 指针,指向 int | p 不能改指向;目标可以改 |
const int* const p | 指向 const int 的 const 指针 | 两边都不能改 |
参考代码里实测过:const int* pc = &a; 之后 pc = &b; 合法,重新指向 b 打印出 2;而通过 pc 写 *pc = 5 会编译失败。反过来 int* const cp = &a; 可以 *cp = 5,但 cp = &b 编译不过。两个都加 const 就都锁死。
函数参数里的 const T& 是另一回事:引用本身天生不能重绑定,这里的 const 限制的是「通过这个引用不能修改目标」。它和 T& 的区别,就是调用方能不能预期「这个参数不会被改」。接口设计上,能标 const 就标,读代码的人省一次推理。
悬垂指针与 string_view 的陷阱
悬垂指针的来源就那么几个:对象在栈上,函数返回了;对象在堆上,被 delete 了;容器扩容,旧内存被释放了;对象是共享所有权,引用计数到 0 了。共同点都是「地址还在,对象没了」。
std::string_view 是这类问题的重灾区。它只保存一个字符指针加一个长度,不拥有字符,也不负责字符什么时候销毁。作为函数参数(调用方持有字符串)它非常好用,零拷贝;但当成返回值,麻烦就来了:
#include <iostream>
#include <string>
#include <string_view>
std::string_view make_view() {
std::string s = "short-lived text";
return std::string_view(s); // s 在函数结束时销毁,view 悬空
}
int main() {
auto sv = make_view();
std::cout << "size=" << sv.size() << " text=" << sv << "\n";
return 0;
}
编译能过,-Wall -Wextra 也不报警。本机运行输出是乱码,长度 16 是对的,内容已经不是原文:
size=16 text=<一串不可打印字节>
把字符串换成长到必须在堆上分配的版本(超过 SSO 缓冲),输出变成空串;再单独打印一次,偶尔又能看到原文被覆盖成别的内容。原因是函数返回时栈帧被回收,下一次输出调用又把那段栈或那块堆内存用掉了。
这里要说清楚:「悬垂的 string_view 仍然打印出原文」是确实会发生的情况,只要那块内存在打印前没被覆盖。这种版本比乱码危险得多,因为调试时看起来一切正常,上线换个负载就崩或者显示别人的数据。本文在本机反复试了几次,拿到的都是乱码和空串,没能复现「原样打印」的版本;这个分支属于未在本机实测,但机制上完全成立——内存没被覆写,字节就还在。
避免办法很直接:函数返回 std::string 而不是 string_view;确实要零拷贝,就让调用方持有字符串,函数只接收 std::string_view 参数;异步任务、线程里保存 string_view,必须确保源字符串活得比任务久。这类生命周期问题 ASan 能抓到一部分,本机没有装 ASan,未实测。
std::unique_ptr 在这里只提一句:它独占所有权,用 std::make_unique 创建,不能拷贝只能移动,离开作用域自动释放。智能指针的取舍放到第六篇展开,这里先记住「所有权明确」比「到处裸指针」稳。
指针家族还有一个分支是函数指针,比如 int (*op)(int, int),常用来做回调表,这里只留个印象,不展开。
现象、原因、先查什么
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
| 扩容后旧指针/迭代器读出的值变了 | 容器重新分配,旧内存释放,元素搬到新地址 | 在 push_back/insert 之后是否还在用旧指针、旧迭代器、旧引用;先查 capacity 和 data() 的变化 |
| 指针指向的内容突然变成别人的数据 | 悬垂指针,内存被新对象复用 | 列出这个指针的生命周期,看它指向的对象什么时候析构;对比新旧对象地址 |
| 程序崩在地址 0 附近,退出码 0xC0000005 | 解引用空指针或野指针 | 检查指针初始化没有;有没有在 delete 之后没置空 |
返回 string_view 的函数,内容乱码或为空 | 视图指向了已销毁的局部字符串 | 看被指向的 std::string 是不是局部变量;改成返回值或由调用方持有 |
函数里 sizeof(数组参数) 得到 8 | 数组退化成了指针,长度信息丢失 | 参数是否写成了 int a[]/int a[5];改用 std::span、长度参数或按引用传数组 |
assignment of read-only location | const 修饰的位置看错了 | 从右往左读声明,确认 const 管的是指针本身还是目标 |
| 双重释放,退出码 0xC0000374 | 两个指针拥有同一块内存,析构两次 | 查拷贝构造/赋值是否浅拷贝了拥有所有权的指针;改用 unique_ptr |
| 指针算术越界但没立刻崩 | 未定义行为,读到了别的对象或填充 | 确认下标范围;用 at()、迭代器或 std::span 加边界 |
这张表里最容易被忽略的是最后一条。崩溃其实是最好的结果,因为你能立刻知道出事了;真正贵的是「读到一个看起来合理的数」,然后带着它继续算下去。
边界与代价:裸指针换来了什么
C++ 不检查指针,不是忘了,是拿运行时检查换性能。这笔交易的账单要看清:
- 裸指针没有大小信息。一个
int*不知道它指向一个int还是一个长度为 100 的数组。所有边界判断都得靠人,或者靠额外传长度。 - 没有所有权语义。函数收一个
T*,调用方不知道函数会不会delete它,也不知道借出去之后自己还能不能用。接口里裸指针一多,所有权就成了一片模糊地带。 - 引用换来安全,也换来限制。引用不能为空、不能重绑定,所以「可能没有」「要换目标」这两个需求它表达不了,只能退回指针或
optional。引用也存不进大多数容器。 string_view的零拷贝有前提。源字符串必须活得比你久,跨线程、跨异步、存进结构体长期持有都要重新审一遍。省下的拷贝成本,可能被一次悬垂访问全部还回去。- 未定义行为的表现不稳定。同一段越界代码,
-O0下读到垃圾,-O2下可能被优化成另一条路径。别用「Debug 版正常」当证据。 - 指针宽度随平台变。32 位进程里指针 4 字节,64 位 8 字节;把指针塞进
int或者按固定宽度序列化,在换平台时会碎。要存就存uintptr_t,而且只在同一进程内有效。 - 工具能救命,但不是万能。ASan 抓越界和 use-after-free 效果很好,本机没装,只能靠
-Wall -Wextra、代码审查和复现实验。把生命周期写短、把所有权收敛到少数几个类,比事后排查便宜。
换个角度:指针是 C++ 能贴近硬件的原因之一。你能直接表达「这块内存的第 3 个 4 字节」,也能把 C 库、操作系统接口接进来。代价是编译器不再替你做主,每个地址的有效性都成了程序员的责任。
当天能验证的练习
- 复现扩容实验:
reserve(3),记下data(),连续插入到第 4 个,比较地址和容量;再把reserve改成 10 重跑,观察地址是否一直不变,理解「提前预留」为什么能救指针。 - 写一个返回局部
std::string的string_view,分别用std::cout和printf打印,记录每次结果;再把返回类型改成std::string对照。多跑几次,看结果是否稳定。 - 写一个
void f(int a[5]),在函数里打印sizeof(a),和main里的sizeof(arr)对比;再改成void f(int (&a)[5])或std::span<int>,确认长度回来了。 - 把
const int*、int* const、const int* const各写一遍,尝试改指向和改值,抄下每条编译错误,练到能一眼读出声明。 - 用
std::make_unique<int[]>(5)管理一个数组,打印get(),再std::move给另一个指针,确认移动后源指针变成nullptr。
小结
三句话:指针只保存地址,不保存对象是否还活着,容器扩容、delete、作用域结束都会让它悬空;引用是必须有效的别名,不能为空也不能重绑定,能用引用表达的地方优先用引用;数组会退化成指针,长度信息一旦丢失就只能靠额外参数或 std::span 找回来。
到这里,地址和生命周期讲完了,但还有一个问题没回答:一个对象从创建到销毁,中间到底发生了什么,资源凭什么能自动释放。下一篇讲类、构造析构与 RAII,把那套「资源寿命绑在对象作用域上」的机制拆开。