1. 一个返回 -1 的二分查找,把我从 print 大法逼到了 GDB
数组 {1, 2, 4, 5, 6} 里明明有 5,二分查找却返回 -1;同一份代码查 6 时,又能准确返回下标 4。这种“部分输入对、部分输入错”的 bug 最耗人——它不崩、不报警,只在你最不想它出错的那组参数上安静地给出错误答案。最初我往函数里插了三个 print,跑一遍、扫一眼、再挪 print 的位置,来回七八次才隐约觉得区间收窄的方向不对。后来换成 GDB,一条条件断点把断点只压到 target == 5 的那次调用上,再挂一个 watchpoint 盯住 floor,几十秒就看清楚了区间是怎么被跳过去的。下面把这套流程完整走一遍:怎么编译、条件断点怎么写、watchpoint 该盯谁、以及那几个让我白折腾半天的坑。
需要模型API调用? 免费领10W Token,多模型网关一键接入 Claude、DeepSeek 等主流模型。
2. 先把现场搭起来:一份能复现的代码、一次带 -g 的编译
2.1 把 bug 固定在二分查找里
调试最怕的是现场不干净。在挂断点之前,先把问题压缩到一个 main 加一个函数、三行调用、三个预期值,任何一次结果对不上都能立刻看出来。
c复制#include <stdio.h>
int binary_search(int *ary, unsigned int ceiling, int target)
{
unsigned int floor = 0;
while (ceiling > floor)
{
unsigned int pivot = (ceiling + floor) / 2;
if (ary[pivot] < target)
floor = pivot + 1;
else if (ary[pivot] > target)
ceiling = pivot - 1; /* 正确的代码应该为:ceiling = pivot */
else
return pivot;
}
return -1;
}
int main(int argc, char *argv[])
{
int a[] = {1, 2, 4, 5, 6};
printf("%d\r\n", binary_search(a, 5, 7)); /* 期望 -1 */
printf("%d\r\n", binary_search(a, 5, 6)); /* 期望 4 */
printf("%d\r\n", binary_search(a, 5, 5)); /* 期望 3,实际 -1 */
return 0;
}
这段代码用的是“上界不含”的写法:搜索区间是 [floor, ceiling),ceiling 指向的位置永远不参与比较。理解了这一点,两条更新语句的对错就很好判断:ary[pivot] < target 时目标在右半边,pivot 本身已经被排除,所以 floor = pivot + 1 是对的;ary[pivot] > target 时目标在左半边,pivot 同样要排除,但 ceiling 本来就是“不含”的边界,正确写法只要 ceiling = pivot 就够了。代码里却写成了 ceiling = pivot - 1,多减了一个 1,把 pivot 左边那个元素也一起划出了搜索范围。
这就是“部分输入对”的来源。答案只要不落在被误删的那个位置上,结果就还是对的;一旦落在上面,函数就会提前认为区间已空,返回 -1。它不是随机错误,而是沿着一条特定的分支路径才会出现的错误——这类 bug 靠多跑几次碰运气是抓不到的。
2.2 编译参数决定你后面能看到什么
按最朴素的方式编译,然后直接进调试器:
bash复制gcc -g test.c
gdb a.out
gcc -g test.c 没有写 -o,输出文件默认就是当前目录下的 a.out,所以 gdb a.out 能对上。-g 的作用是把调试信息写进可执行文件:变量名、类型、作用域,以及源码行号和机器指令地址之间的映射关系。没有它,p floor 只会甩给你一句 No symbol "floor" in current context——不是变量不存在,是调试器根本不知道有这么个名字。
另一个要守住的底线是:调试阶段不要加 -O2 之类的优化。优化打开后,局部变量可能被塞进寄存器、被复用,甚至整段被消除,floor 这个名字和任何一块内存地址都不再一一对应,watchpoint 挂上去也只能盯住一个已经不参与运算的副本。
提示:如果工程里已经有别的
a.out,进 GDB 后先用file a.out或info sources确认自己调的是刚编出来的那个文件,别在旧二进制上白忙。
2.3 三次调用,三个结果:先确认问题边界
不带任何断点,先把程序跑一遍,把三次调用排成一张表:
| 调用 | 期望返回 | 实际返回 | 是否一致 |
|---|---|---|---|
binary_search(a, 5, 7) |
-1 | -1 | 一致 |
binary_search(a, 5, 6) |
4 | 4 | 一致 |
binary_search(a, 5, 5) |
3 | -1 | 不一致 |
这张表的价值在于排除了大量可能性。三次调用用的是同一个数组,第一次和第二次结果都对,说明函数骨架、参数传递、pivot 的取中点方式都没问题;错的只可能是某一条更新语句在特定分支下把区间收错了。嫌疑范围立刻从“整个函数”缩到 floor = pivot + 1 和 ceiling = pivot - 1 两行。
对 target = 5 手工推一遍就更清楚了:初始 floor = 0、ceiling = 5,第一次取 pivot = 2,ary[2] = 4 < 5,于是 floor = 3;第二次取 pivot = (5 + 3) / 2 = 4,ary[4] = 6 > 5,于是 ceiling = 4 - 1 = 3;此时 ceiling 和 floor 都是 3,循环条件 ceiling > floor 不成立,直接跳出返回 -1。而正确写法 ceiling = pivot = 4 会让区间保持 [3, 4),下一轮 pivot = 3、ary[3] = 5,正好命中目标。
顺带说一个更危险的后果:ceiling 是 unsigned int,如果某次 pivot 落到 0,而 ary[0] 又大于 target,pivot - 1 会在无符号数上回绕成一个极大的值。循环非但不会退出,还会拿着这个巨大的上界去访问数组边界之外的内存。这也是为什么这类“只是返回错值”的 bug 值得认真调——它在某些输入上会从逻辑错误升级成越界。
手工推演在这个例子里够用,是因为变量只有两个、状态只有两轮。真实项目里 floor 和 ceiling 可能是结构体成员、可能被多个分支改写、可能被别的线程动过,靠脑补算不出来,这时候就该让 GDB 替你盯。
3. 条件断点:让断点只在 target == 5 时停下来
3.1 普通断点为什么会被前两次调用淹没
最直觉的做法是在函数入口下断点:
bash复制gdb a.out
(gdb) b binary_search
(gdb) run
程序会停在第一次调用,也就是 target = 7 那次。想看第三次调用,得连按两次 c 跳过去。三次调用还能忍,但如果这个函数是在一个上万次的循环里被调用、只有某一轮的某个参数组合才触发 bug,靠连按 c 就完全不可行了。
更麻烦的是,断点停在函数入口时,floor 还没初始化、pivot 还没算出来,你看到的是一堆初值。想看到出事那一行,还得单步走进去,而单步又会被前两轮调用反复打断。这两个问题叠在一起,就是很多人放弃调试器、回去加 print 的真实原因。
GDB 允许用户设置条件断点,正好把这个问题一次解决。
3.2 b binary_search if target == 5 的求值时机与作用域
bash复制(gdb) b binary_search if target == 5
Breakpoint 1 at 0x1139: file test.c, line 5.
(gdb) run
现在只有第三次调用会触发断点,前两次调用会被直接放行。
条件断点的执行模型值得说清楚:GDB 仍然在 binary_search 的第一条指令上埋断点,每次程序执行到这里都会陷入调试器,然后 GDB 在当前栈帧里求值 target == 5。为真才把控制权交给你,为假就自动继续。也就是说,条件表达式是在“断点所在位置的作用域”里求值的。
作用域这一条直接决定了条件能不能写。target 是 binary_search 的形参,只有进入这个函数、栈帧建立之后才存在。如果把断点下在 main 里:
bash复制(gdb) b main if target == 5
No symbol "target" in current context.
GDB 会明确告诉你当前上下文里没有这个名字。遇到这种报错,先别怀疑 GDB,回头看看条件里引用的变量是不是断点位置真的可见。
还有个代价问题:条件断点的求值发生在每一次命中的时候。断点落在一个执行几十万次的热点函数上,条件再复杂一点,程序会慢到你以为它卡死了。条件越简单越好,能用参数比较就别去解引用指针、别调用函数。
3.3 断点编号、条件修改与禁用
条件断点下多了,管理就成了问题。GDB 给每个断点分配编号,后面所有操作都靠这个编号定位:
bash复制(gdb) info breakpoints
Num Type Disp Enb Address What
1 breakpoint keep y 0x0000000000001139 in binary_search at test.c:5
stop only if target == 5
breakpoint already hit 1 time
输出里会直接写清楚“stop only if target == 5”,以及这个断点已经被命中过几次。后者很有用:如果你以为条件会把前两次调用过滤掉,结果 hit 次数是 3,那就说明条件压根没生效。
几个常用操作:
| 操作 | 命令 | 说明 |
|---|---|---|
| 给已有断点加条件 | condition 1 target == 6 |
断点编号 1,条件整体替换 |
| 临时关掉断点 | disable 1 |
保留配置,不再触发 |
| 重新启用 | enable 1 |
恢复触发 |
| 彻底删除 | delete 1 |
不留痕迹,慎用 |
| 按次数跳过 | ignore 1 2 |
前 2 次命中不中断,常见做法 |
改条件比删了重建更省事,尤其是断点还带着别的配置时。改完记得再 info breakpoints 看一眼,确认条件真的换上了——GDB 不会在 condition 执行成功时给你很显眼的回显,一行不吭声地接受是常态。
停到第三次调用之后,可以先把两个变量的初值打出来:
bash复制(gdb) p floor
$1 = 0
(gdb) p ceiling
$2 = 5
但这两个值是函数入口的值,而出事的是后面那次更新。p 只能看到“现在是多少”,看不到“什么时候变的、变成了多少、是谁改的”。这正是 watchpoint 要补上的那一段。
4. watchpoint:盯住 floor 和 ceiling 的每一次改写
4.1 watch 和 print 的根本差别:谁在发现变化
p floor 是“我主动去看”,看的那一刻值是多少就是多少,中间发生过什么它不知道。如果用 print 大法,你就得在每一次可疑的赋值后面插一行打印,然后再猜下一处该插在哪里——这个猜的过程就是反复编译、反复挪位置的根源。
watchpoint 反过来:你告诉 GDB 一个变量或一块内存地址,之后只要这块内存被写,程序就停下来。你不需要知道它在哪里被改,GDB 自己盯着。对一个“不知道哪一行改坏了状态”的 bug 来说,这个转换是决定性的。
它还特别适合读别人代码的场景。你对某个变量在整条调用链里的生命周期完全没概念时,挂一个 watch,让程序把每一次改写的位置都报给你,比通读一遍源码再猜快得多。
4.2 wa floor if target == 5 的完整执行流
顺序很关键:watch 必须在变量可见之后才能挂。所以先用条件断点停在 binary_search 里面,再设 watch。
bash复制(gdb) b binary_search if target == 5
(gdb) run
(gdb) wa floor if target == 5
Hardware watchpoint 2: floor
(gdb) wa ceiling if target == 5
Hardware watchpoint 3: ceiling
(gdb) c
这里给 floor 和 ceiling 各挂了一个 watch,并且都带上了 if target == 5 的条件。条件不是可选项:floor 是栈上的局部变量,三次调用各有各的栈帧,不加条件的话前两次调用里的每一次改写都会让你停一下,输出会乱成一锅粥。
继续执行之后,看到的轨迹是这样:
| 停下的位置 | floor | ceiling | pivot 计算结果 | 发生了什么 |
|---|---|---|---|---|
| 条件断点命中(函数入口) | 0 | 5 | — | 第三次调用,target = 5 |
| watch 第一次命中 | 3 | 5 | 2 | ary[2] = 4 < 5,执行 floor = pivot + 1 |
| watch 第二次命中 | 3 | 3 | 4 | ary[4] = 6 > 5,执行 ceiling = pivot - 1 |
| 循环退出 | 3 | 3 | — | ceiling > floor 为假,返回 -1 |
第二行和第三行之间就是全部答案。pivot 明明算到了 4、ary[4] 明明大于 target,下一步却把 ceiling 压到了 3,等于把下标 3 这个位置直接扔掉了,而 5 恰好就在下标 3 上。整个过程不需要单步、不需要插 print,程序自己把证据摆在了你面前。
watch 命中时 GDB 默认会打印新旧值两行,如果只想要一行摘要,可以关掉这个回显。命中之后 bt 一下能立刻看到是谁写的这块内存;对我们这个例子来说是 binary_search 自己,但在多层调用里,这一步常常能把“某处莫名其妙改了全局状态”的案子直接破掉。
4.3 给内存地址下 watch:wa *0x7fffffffda40 什么时候才该用
有时候你手里根本没有变量名:符号被裁掉了、变量是运行时算出来的、或者你想盯的是某个结构体里的一块字段。这时候可以绕过符号,直接盯地址:
bash复制(gdb) wa *0x7fffffffda40
这条命令的意思不是“盯着这个数字”,而是“盯着这个地址上的内存,它被写就停下来”。地址从哪来?最直接的办法是问 GDB:
bash复制(gdb) p &floor
$4 = (unsigned int *) 0x7fffffffda40
(gdb) wa *0x7fffffffda40
但这个地址是有保质期的。它是栈上的位置,每次进程重新启动,栈布局都可能因为环境变量长度、调用深度、地址随机化而改变。把 0x7fffffffda40 抄进脚本里下次接着用,轻则 watch 挂在了一块毫不相干的内存上,重则直接报 Cannot access memory at address 0x7fffffffda40。
要复用,就别写死。在命令脚本里现算:
bash复制(gdb) set $addr = &floor
(gdb) wa *$addr
$addr 是 GDB 的便利变量,每次运行到这一行时才求值,地址永远是当前这一帧的真实地址。地址断点的正确用法是“临时、当场、用完就丢”,不是“抄下来存着”。
4.4 在值变化的那一刻改值:把后悔药握在手里
watch 停在“值刚刚被改坏”的那一刻,这个时机很适合做一件事:把它改回去,看结果会不会变成期望值。
bash复制(gdb) set var ceiling = 4
(gdb) c
把 ceiling 从 3 手动改成 4,继续跑。如果函数这次返回 3、和期望一致,那这个 bug 就彻底锁定了——问题百分之百出在 ceiling = pivot - 1 这一行,跟 floor 的更新、跟 pivot 的取整方式都没有关系。这种“改一个值、看路径分叉”的验证方式,比盯着代码反复推演要可靠得多,尤其是在你不熟悉的一段代码里。
要提醒一句:set var 只是验证手段,不是修复。它改的是内存里的值,不改进程外的源码文件;下次不带 GDB 跑,问题照旧。验证完回到编辑器里把 pivot - 1 改成 pivot,重新编译,再跑一遍那三行调用确认全部对上,这一步不能省。
注意:
set var改的是当前栈帧里的变量。如果同名变量在别的作用域里还有一份,先把bt和frame确认清楚,别在错误的帧上改了半天。
5. 避坑与排查:条件断点和 watchpoint 的五个翻车现场
5.1 条件断点报 No symbol,或者一次都不命中
现象:敲下 b binary_search if target == 5 之后 GDB 回一句 No symbol "target" in current context;或者断点设成功了,但跑完整个程序一次都没停。
原因:条件表达式是在断点所在位置的作用域里求值的。断点下在 main,target 这个形参在 main 的栈帧里根本不存在;断点下在某个内联展开后的位置,条件里引用的名字也可能已经被优化掉。
解决:先把断点下在变量可见的那个函数里,run 停住之后用 p target 确认这个名字真的能打印出来,再回头加条件。如果条件断点下成功了却一次不命中,第一件事是 info breakpoints 看命中次数,第二件事是核对条件里的字面量——target == 5 和 target = 5 在 GDB 里是两个完全不同的东西。
5.2 wa floor 提示 No symbol "floor" in current context
现象:刚进 GDB 就敲 wa floor,直接被拒绝,说当前上下文没有这个符号。
原因:floor 是函数内部的局部变量,只有在 binary_search 的栈帧建立之后才有地址。程序还没跑起来的时候,GDB 手上没有任何一帧,自然找不到这个名字。
解决:顺序必须是“先断点、再运行、停在函数里、最后挂 watch”。或者用 wa *(int *)&floor 这种显式取址的写法,语义上更明确——你盯的不是名字,是名字背后的那块内存。
5.3 watch 挂上去之后程序像卡住了,或者停的位置完全不对
现象:加了 watch 之后 c 一直停,输出刷屏;或者停下来的时候 target 是 7、是 6,根本不是你想看的那次调用。
原因:watchpoint 是按地址触发的,不带条件时,前两次调用里 floor 的每一次改写都会命中。如果这个变量还在一个循环里被反复更新,命中次数会成倍上涨,每一次命中都要把控制权交回 GDB,速度自然就下来了。
解决:给 watch 也加上条件,wa floor if target == 5,把范围压到出错的那一次调用。同时盯的变量控制在一两个,硬件 watchpoint 的数量是有限的,挂太多会被降级或者直接失败。
5.4 p 出来是 optimized out,watch 的行为也跟平时不一样
现象:p floor 显示 <optimized out>;或者同一个程序,加优化和不加优化时 watch 命中的次数、时机都不相同。
原因:编译带了优化,局部变量被放进寄存器、被复用,甚至整段被消除。符号和内存地址不再一一对应,watch 挂上去盯的可能只是一份过时的副本。
解决:回到 gcc -g -O0 重新编译,确认自己调的是刚生成的那个 a.out。调试阶段就别想着“顺便看看优化后的行为”,那是在给自己加难度。
5.5 写死的地址断点下次就失效
现象:wa *0x7fffffffda40 这次跑得好好的,第二天再跑直接报 Cannot access memory at address 0x7fffffffda40,或者停下来的位置跟 floor 毫无关系。
原因:那是栈地址,每次进程启动栈布局都可能变化。地址随机化、环境变量长度、调用深度,任何一个变了,同一个数字指向的就是别的地方。
解决:永远现取现用,p &floor 拿到地址再挂;要写进脚本就用 set $addr = &floor 这种在运行时求值的写法,不要把一个具体数字固化下来。
6. 把这套流程固化成 GDB 命令脚本:四条命令的复用姿势
调通一次之后,把这一串动作存成文件,下次换台机器、换个同事接手,一条命令就能复现同样的现场:
bash复制# 保存为 bisect.gdb,用法:gdb -x bisect.gdb ./a.out
set pagination off
# 只在 target == 5 的那次调用上停下
break binary_search if target == 5
run
# 停在函数里之后再挂 watch,此时 floor / ceiling 才可见
watch floor if target == 5
watch ceiling if target == 5
continue
set pagination off 是给批处理用的,避免输出过长时 GDB 弹一个分页提示把脚本卡住。run 之后的命令不会立刻执行,而是等断点命中、控制权回到 GDB 之后才依次生效——这也是 watch 能写在 run 后面的原因,那时候栈帧已经建好了。用 gdb -x bisect.gdb ./a.out 跑,一次就能停到出事的那一行,比手敲五条命令稳得多。
改完代码之后,我习惯固定走四步,一步都不跳:
| 步骤 | 命令 | 看什么 |
|---|---|---|
| 1 | gcc -g -O0 test.c |
确认没带优化、没报错 |
| 2 | gdb -x bisect.gdb ./a.out |
确认停在第三次调用、target 是 5 |
| 3 | p floor / p ceiling / set var ceiling = 4 |
验证改动前后路径是否分叉 |
| 4 | 去掉 GDB 直接跑 | 三行输出全部对上期望值 |
这套东西的价值不在这一次。二分查找这个 bug 之所以值得写下来,是因为它的形状太典型了:不崩、不报警、只在一部分输入上错,而且错的根源藏在一个“看起来对得很自然”的 - 1 里。从那以后我每次遇到这类纯逻辑 bug,都会先写一个最小复现的 main,把三次调用和期望值写进注释,再用条件断点把范围压到出错的那一次,最后才动源码——顺序反过来,往往就是改三行、错两行、再改回去。希望帮到你。
