gdb的使用

深碍√TFBOYSˉ_ 2022-08-29 12:51 235阅读 0赞

gdb 的用法

在Linux应用程序开发中，最常用的调试器是gdb，它可以在程序中设置断点、查看变量值、一步一步跟踪程序的执行过程。利用调试器的这些功能可以方便地找出程序中存在的非语法错误。

一、启动和退出gdb  
gdb调试的对象是可执行文件，而不是程序的源代码。

如果要使一个可执行文件可以被gdb调试，那么在使用编译器gcc编译程序时需要加入-g选项。-g选项告诉gcc在编译程序时加入调试信息，这样才可以调试这个被编译的程序。

例：计算1~100的和，应该输出5050

\# cat -n test.c

1  \#include <stdio.h>

3 int get\_sum(int n)

4  \{  
     5   int sum = 0, i;

6   for (i=0;i<n;i++)

7    sum +=i;

8    return sum;

9   \}

11  int main()

12    \{  
   13    int i = 100, result;

14    result = get\_sum(i);

15   printf("1+2+...+%d=%d\\n",i,result);

16    return 0;

17  \}

编译并运行该程序：

\# gcc -g test.c -o test

\# ./test

1+2+...+100=4950

（一）、调试一个程序的命令格式  
格式：gdb <可执程序文件名>

例：\#gdb test

或  \#gdb

(gdb) file test

(二)、退出  
    (gdb) quit

二、显示和查找程序的源代码  
在调试时，一般要查看程序的源代码。list 命令用于列出程序的源代码，使用格式如下：

l list  显示10行代码，若再次运行该命令则显示接下来的10行代码

l list 5,10  显示源代文件test.c中的第5行到第10行的代码，

l listtest.c:5,10  显示源文件test.c中第5行到第10行的代码，在调试含有多个源文件的程序时使用

l listget\_sum  显示get\_sum函数周围的代码

l listtest.c:get\_sum 显示源文件test.c中get\_sum函数周围的代码，在调试含多个源文件的程序时使用

l search  <字符串> 用来从当前行向后查找第一个匹配的字符串

l reverse-search<字符串> 用来从当前行向前查找第一个匹配的字符串

三、执行程序和获得帮助  
使用gdb test或(gdb) fieltest只是装入程序，程序并没有运行，如果要使程序运行，在gdb提示符下输入run即可。

(gdb) run

Starting program:/tmp/test

1+2+...+100=4950

Program exitednormally.

如果想要详细了解gdb某个命令的使用方法，可以使用help命令

(gdb)help list

(gdb)help all

四、设置和管理断点  
在调试程序时，往往需要程序在运行到某行、某个函数或某个条件发生时暂停下来，然后查看此时程序的状态，如各个变量的值、某个表达式的值等。为此，可以设置断点（break）。断点使程序运行到某个位置时暂停下来，以便检查和分析程序。

1、 以行号设置断点

在gdb中，大部分都是使用break命令为程序设置断点。而指定断点时，最常用的是为某行设置断点。例：

(gdb) break 7

Breakpoint 1 at0x80483c0: file test.c, line 7.

然后我们输入run命令运行程序：

(gdb) run

Starting program:/tmp/test

Breakpoint 1,get\_sum (n=100) at test.c:7

7          sum +=i;

可以看到，程序运行完第6行的指令后就暂停了，第7行的代码并没有执行而是被gdb的断点中断了。此时，我们可以查看各个变量和表达式的值，以了解程序的当前状态。

2、以函数名设置断点

在break命令后跟上函数名，就可以为函数设置断点。例：

(gdb) break  get\_sum

Breakpoint 1 at0x80483aa: file test.c, line 5.

(gdb) run

Starting program:/tmp/test

Breakpoint 1,get\_sum (n=100) at test.c:5

5         int sum = 0,i;

可以看到，程序在第5行停了上来。

3、以条件表达式设置断点

程序在运行过程中，当某个条件满足时，程序在某行中断暂停执行

方法1 命令格式：break行号或函数名 if  条件

例：

(gdb) clear

Deleted breakpoint1

(gdb) break7 if i==99

Breakpoint 2 at0x80483c0: file test.c, line 7.

(gdb) run

The program beingdebugged has been started already.

Start it from thebeginning? (y or n) y

Starting program:/tmp/test

Breakpoint 2,get\_sum (n=100) at test.c:7

7          sum +=i;

可以看到，运行程序后在i==99时，程序中断在第7行。

方法2  watch <条件表达式>

例：(gdb) watchi==99

No symbol"i" in current context.

(gdb) list 6

1       \#include <stdio.h>

3       int get\_sum(int n)

4        \{  
5         int sum = 0,i;

6         for (i=0;i<n;i++)

7          sum +=i;

8          return sum;

9         \}

(gdb) break 6

Breakpoint 1 at0x80483b1: file test.c, line 6.

(gdb) run

Starting program:/tmp/test

Breakpoint 1,get\_sum (n=100) at test.c:6

6         for (i=0;i<n;i++)

Gdb运行后，以命令watch i==99设置条件断点，但是失败了，gdb提示在当前程序的上下文中没有符号i，这是因为此时test程序没有运行，变量i还没有被定义。

为了解决这个问题，首先在第6行设置断点，然后使用run命令运行程序，程序暂停在第6行，此时第5行的语句已经被执行，所以变量i已经定义。这时就可以使用watch i==99设置断点了。

4、查看当前设置的断点

使用info breakpoints命令可以查看当前所有的中断点，例如：

(gdb) break 7

Breakpoint 1 at0x80483c0: file test.c, line 7.

(gdb) break 15 ifresult=5050

Breakpoint 2 at0x8048405: file test.c, line 15.

(gdb) info breakpoints

Num Type           Disp Enb Address    What

1   breakpoint     keep y  0x080483c0 in get\_sum at test.c:7

2   breakpoint     keep y  0x08048405 in main at test.c:15

stop only if result = 5050

其中：Num  表示断点的编号

Type 说明类型，类型为breakpoint是指中断

Disp 指明中断点在生效一次后是否失去作用，是则为disp，不是则为keep

Enb 说明中断点是否有效，有效则为y，无效则为n

Address列  说明中断所处的内存地址

What列  列出中断发生在哪个函数的第几行

Stop only if result==5050  说明这是一个条件中断

5、使中断失效或有效

disable <断点编号> 可以使某个断点失效，程序运行到该断点时不会停下来而是继续运行

enable <断点编号> 可以使某个断点恢复有效

例：

(gdb) info breakpoints

Num Type           Disp Enb Address    What

1  breakpoint     keep y   0x080483c0 in get\_sum at test.c:7

2  breakpoint     keep y   0x08048405 in main at test.c:15

stop only if result = 5050

(gdb) disable 2

(gdb) info breakpoints

Num Type           Disp Enb Address    What

1  breakpoint     keep y   0x080483c0 in get\_sum at test.c:7

2  breakpoint     keep n   0x08048405 in main at test.c:15

stop only if result = 5050

(gdb) enable 2

(gdb) info breakpoints

Num Type           Disp Enb Address    What

1  breakpoint     keep y   0x080483c0 in get\_sum at test.c:7

2  breakpoint     keep y   0x08048405 in main at test.c:15

stop only if result = 5050

6、删除断点

l clear   删除程序中所有的断点

l clear<行号>  删除此行的断点

l clear<函数名> 删除该函数的断点

l delete<断点编号> 删除指定编号的断点。如果一次要删除多个断点，各个断点编号以空格隔开

例：

(gdb) break 6

Breakpoint 1 at0x80483b1: file test.c, line 6.

(gdb) break 7

Breakpoint 2 at0x80483c0: file test.c, line 7.

(gdb) break 8 ifsum==5050

Breakpoint 3 at0x80483cf: file test.c, line 8.

(gdb) info breakpoints

Num Type           Disp Enb Address    What

1   breakpoint     keep y  0x080483b1 in get\_sum at test.c:6

2   breakpoint     keep y  0x080483c0 in get\_sum at test.c:7

3   breakpoint     keep y  0x080483cf in get\_sum at test.c:8

stop only if sum == 5050

(gdb) clear 6

Deleted breakpoint1

(gdb) info breakpoints

Num Type           Disp Enb Address    What

2   breakpoint     keep y  0x080483c0 in get\_sum at test.c:7

3   breakpoint     keep y  0x080483cf in get\_sum at test.c:8

stop only if sum == 5050

(gdb) delete 2 3

(gdb) info breakpoints

No breakpoints orwatchpoints.

7、display <表示式>   在每次程序停在断点位置时，自动显示表达式中的内容

8、commands

>命令

>end      结束命令输入

作用：指定在程序到达断点位置时需要执行的调试器命令

五、查看和设置变量的值  
当程序执行到中断点暂停执行时，需要查看变量或表达式的值，借此了解程序的执行状态

1、print命令

作用：print命令一般用来打印变量或表达式的值，也可以用来打印内存中从某个变量开始的一段

存区域的内容，还可以用来对某个变量进行赋值。

格式：

print  <变量或表达式>  打印变量或表达式的当前值,gdb会用伪变量（$n）来保存输出值以备用

Print  <变量=值>；   对变量进行赋值

Print  <表达式@要打印的值的个数n>  打印以表达式值开始的n个数

例：

(gdb) break 7

Breakpoint 4 at0x80483c0: file test.c, line 7.

(gdb) run

Starting program:/tmp/test

Breakpoint 4,get\_sum (n=100) at test.c:7

7          sum += i;

(gdb)print i<n   打印出i<n表达式的值，显然这个表达式为真，因此值为1

$1 = 1

(gdb) print i

$2 = 0

(gdb) print sum

$3 = 0

(gdb) print i=200

$4 = 200

(gdb) continue

Continuing.

1+2+...+100=200

Program exitednormally.

2、whatis 命令

作用：用来显示某个变量或表达式值的数据类型

格式：whatis <变量或表达式>

例：

(gdb) break 7

Note: breakpoint 4also set at pc 0x80483c0.

Breakpoint 5 at0x80483c0: file test.c, line 7.

(gdb) run

Starting program:/tmp/test

Breakpoint 4,get\_sum (n=100) at test.c:7

7          sum += i;

(gdb) whatis i

type = int

(gdb) whatis sum+0.5

type = double

3、set 命令

作用：用来给变量赋值

格式：set variable 变量=值   相当于print 变量=值

例：set variable i=200，相当于print i=200

六、控制程序的执行  
当程序执行到指定的中断点，查看了变量或表达式的值后，可以让程序继续运行。也可以让程序一步一步地执行，或可以让程序地直运行下去直到下一个断点或运行完为止。

1、 continue命令

作用：让程序继续运行，直到下一个断点或运行完为止。

格式：continue

2、 kill命令

作用：用于结束当前程序的调试

例：(gdb) kill

Kill the program being debugged? (y or n) y

3、 next和step命令

作用：一次一条地执行程序代码

next和step的区别：

1）、如果遇到函数调用，next会把该函数调用当作一条语句来执行，再次输入next会执行函数调用

后的语句

2）、step则会跟踪进入函数，一次一条地执行函数内的代码，直到函数的代码执行完，才执行函数调

用后的语句

例：next语句的用法

(gdb) list 1,17

1      \#include <stdio.h>

3      int get\_sum(int n)

4      \{  
5        int sum = 0,i;

6        for(i=0;i<n;i++)

7         sum += i;

8        return sum;

9      \}

11     int main()

12     \{  
13       int i=100,result;

14       result = get\_sum(i);

15       printf("1+2+...+%d=%d\\n",i,result);

16       return 0;

17      \}

(gdb) break 13

Breakpoint 1 at 0x80483f0: file test.c, line13.

(gdb) run

Starting program: /tmp/test

Breakpoint 1, main () at test.c:13

13       int i=100,result;

(gdb) next

14       result = get\_sum(i);

(gdb) next

15       printf("1+2+...+%d=%d\\n",i,result);

(gdb) next

1+2+...+100=4950

16       return 0;

(gdb) next

17     \}

(gdb) next

0x4003328b in \_\_libc\_start\_main () from/lib/libc.so.6

(gdb) next

Single stepping until exit from function\_\_libc\_start\_main,

which has no line number information.

Program exited normally.

例：step语句的用法

(gdb) list 1,17

1       \#include <stdio.h>

3       int get\_sum(int n)

4       \{  
5         int sum = 0,i;

6         for(i=0;i<n;i++)

7          sum += i;

8         return sum;

9       \}

11      int main()

12      \{  
13        int i=100,result;

14        result = get\_sum(i);

15       printf("1+2+...+%d=%d\\n",i,result);

16        return 0;

17      \}

(gdb) break 13

Breakpoint 1 at 0x80483f0: filetest.c, line 13.

(gdb) run

Starting program: /tmp/test

Breakpoint 1, main () at test.c:13

13        int i=100,result;

(gdb) step

14        result = get\_sum(i);

(gdb) step

get\_sum (n=100) at test.c:5

5         int sum = 0,i;

(gdb) step

6         for(i=0;i<n;i++)

(gdb) step

7          sum += i;

(gdb) step

6         for(i=0;i<n;i++)

(gdb) step

7          sum += i;

(gdb) step

6         for(i=0;i<n;i++)

(gdb) step

7          sum += i;

4、 nexti和stepi命令

作用：用来单步执行一条机器指令，注意不是单步执行一行语句。单步执行一行语句的命令是

next和step命令

通常一条语句由多条机器指令构成

注意：nexti和next类似，不会跟踪进入函数内部去执行

Stepi和step类似，跟踪进入函数执行。

第二部分  程序调试

一、常用调试技巧

1、代码检查-试运行-出错法：

先运行程序，并观察其输出结果，如果不能正常工作，修改程序后重新尝试

2、取样法：在程序中增加一些语句来获得更多关于程序内部运行情况的信息

3、受控执行法：直接检查程序的执行情况

程序调试可以分为5个阶段

l  测试：找出程序中存在的缺陷或错误

l  固化：让程序的错误可重现

l  定位：确定相关的代码行

l  纠正：修改代码纠正错误

l  验证：确定修改解决了问题

二、有漏洞的程序

如下程序是通过“冒泡排序算法”对一个类型为item的结构数组进行排序，排序方法为基于结构中的成员key以升序排列数组成员。程序用一个样本来数组来测试该程序。

程序：debug2.c

/\*   1 \*/  typedef struct \{  
/\*   2 \*/      char \*data;

/\*   3 \*/      int key;

/\*   4 \*/  \} item;

/\*   5  \*///给结构体赋值

/\*   6 \*/  item array\[\] = \{  
/\*   7 \*/      \{"bill", 3\},

/\*   8 \*/      \{"neil", 4\},

/\*   9 \*/      \{"john", 2\},

/\* 10  \*/      \{"rick", 5\},

/\* 11  \*/      \{"alex", 1\},

/\* 12  \*/  \};

/\* 13  \*/

/\* 14  \*/  sort(a,n)//默认返回值是int，函数声明，若无item \*a会有警告

/\* 15  \*/  item \*a;//声明上面a是指针

/\* 16  \*/  \{  
/\* 17  \*/      int i = 0, j = 0;

/\* 18  \*/      int s = 1;

/\* 19  \*/

/\* 20  \*/      for(; i < n && s != 0; i++) \{  
/\* 21  \*/              s = 0;

/\* 22  \*/              for(j = 0; j < n; j++) \{  
/\* 23  \*/                      if(a\[j\].key >a\[j+1\].key) \{  
/\* 24  \*/                              item t = a\[j\];

/\* 25  \*/                              a\[j\] = a\[j+1\];

/\* 26  \*/                              a\[j+1\] = t;

/\* 27  \*/                              s++;

/\* 28  \*/                      \}

/\* 29  \*/              \}

/\* 30  \*/              n--;

/\* 31  \*/      \}

/\* 32  \*/  \}

/\* 33  \*/  \#include <stdio.h>

/\* 34  \*/  main()

/\* 35  \*/  \{  
/\* 36  \*/          int i;

/\* 37  \*/          sort(array,5);

/\* 38  \*/          for(i = 0; i < 5; i++)

/\* 39  \*/                  printf("array\[%d\] = \{%s,%d\}\\n",

/\* 40  \*/                         i, array\[i\].data,array\[i\].key);

/\* 41  \*/  \}

编译：cc –o debug2 debug2.c

输出结果：

\# ./debug2

array\[0\] = \{john, 2\}

array\[1\] = \{alex, 1\}

array\[2\] = \{(null), 0\}

array\[3\] = \{bill, 3\}

array\[4\] = \{neil, 4\}

我们希望的结果是:

array\[0\] = \{alex, 1\}

array\[1\] = \{john, 2\}

array\[2\] = \{bill, 3\}

array\[3\] = \{neil, 4\}

array\[4\] = \{rick, 5\}

三、程序调试

(一)、捕获数组访问错误

如果想捕获数组方面的错误，最好的方法是增加数组元素的大小，因为这样同时也增加了错误的大小。如果只是在数组的结尾之后读取一个字节，可能会看不到有错误发生，因为分配给程序的内存大小会取整数到操作系统的特定边界，一般分配的内存大小以8K为单位递增。

如果增加数组元素的大小，如在debug.c程序中将item结构中的成员data扩大为一个可以容纳4096个字符的数组，对不存在的数组进行访问时，内存地址就有可能落在分配给这个程序的内存之外的地方，因为数组的每个元素大小为4K，所以错误使用的内存将落在数组结尾之后0K~4K范围内。

1.    测试：将item结构中的成员data扩大为可容纳4096个字符的数组

/\*   1 \*/  typedef struct \{  
/\*   2 \*/      char \*data;       \_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

/\*   3 \*/      int key;

/\*   4 \*/  \} item;

2.    编译：cc –o debug3 debug3.c

3.    执行结果：\#./debug3

\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_\_

(二)、代码检查

当程序的运行情况和预期不同时，最好重新阅读程序。

编译器可以用来帮助完成代码检查

gcc  -Wall -pedantic –ansi

使用man gcc，阅读这三个参数的含义

\-ansi  Thisturns off certain features of GCC that are incompatible

with ISO C90 (when compiling C code)

\-pedantic

Issueall the warnings demanded by strict ISO C and ISO C++;

reject all programs that use forbidden extensions, and some otherprograms that do not follow

ISOC and ISO C++.

\-Wall

This enables all thewarnings about constructions that some users consider questionable and that areeasy

to avoid(or modify toprevent the warning), even in conjunction with macros.

使用gcc的三个选项重新编译debug2.c

\#gcc –Wall –pedantic –ansi –odebug2 debug2.c

debug2.c:15:warning:return typedefaults to “int”

debug2.c: in function “sort”

debug2.c:32: warning:controlreaches end of non-void function

debug2.c: At top level:

debug2.c:35:warning:return typedefaults to “int”

debug2.c:in function “main”

debug2.c:41:warning:controlreaches end of non-void function

(三)、取样法

在程序中添加一些代码来收集更多与程序运行相关的信息的方法。

取样法的常见做法是，在程序中添加printf函数调用以打印出变量在程序运行的不同阶段的值，但需要注意，无论何时程序发生了改动，这一过程都将带来更多的编辑和编译次数，而且，在程序错误被修复后，我们还要把这些额外的代码删除掉。

程序调试时最常用的取样方法有：

1、用C语言的预处理器有选择地包括取样代码，这样只需要重新编译程序就可以包含或去除调试代码。

实现方法： \#ifdef  DEBUG

Printf(“variable x has value =%d\\n”,x);

\#endif

在编译程序时加上编译器标志-DDEBUG。

如果加上这个标志，就定义了DEBUG符号，从而可以在程序中包含额外的调试代码，如果未

加上该标志，这些调试将被删除。

还可以用数值调试宏来完成更复杂的调试应用，例：

\#define BASIC\_DEBUG 1

\#define EXTRA\_DEBUG 2

\#define  SUPER\_DEBUG 4

\#if (DEBUG & EXTRA\_DEBUG)

Prinf ();

\#endif

这样，当编译器标志-DDEBUG=5，将启用BASIC\_DEBUG和SUPER\_DEBUG，但不包括EXTRA\_DEBUG。标志-DDEBUG=0将禁用所有的调试信息。

C语言预处理器定义的一些宏可以帮助调试：

C语言预处理器定义的宏

宏

说明

\_\_LINE\_\_

代表当前行号的十进制常数

\_\_FILE\_\_

代表当前文件名的字符串

\_\_DATE\_\_

mmm dd yyyy格式的字符串，代表当前日期

\_\_TIME\_\_

hh:mm:ss格式的字符串，代表当前时间

例：cinfo.c程序

\#include <stdio.h>

\#include <stdlib.h>

int main()

\{  
\#ifdef DEBUG

printf("Compiled: " \_\_DATE\_\_ " at " \_\_TIME\_\_"\\n");

printf("This is line %d of file %s\\n", \_\_LINE\_\_, \_\_FILE\_\_);

\#endif

printf("hello world\\n");

exit(0);

编译：cc –o cinfo –DDEBUG cinfo.c

执行\# ./cinfo

Compiled: Jul 23 2012 at 07:45:37

This is line 8 of file cinfo.c

hello world

2、使用printf函数帮助调试

在程序中增加一个用为调试标志的全局变量，这使得用户要吧在命令行上通过-d选项切换是否启用调试模式，即使程序已经发布了，仍然可以这么做，访方法同时还会在程序中增加一个用于记录调试信息的函数，例：

if(debug)\{  
    sprint(msg, …);

write\_debug(msg);

应该将调试信息输出到标准错误输出stderr。

当然这样做也有一个明显的不足，就是程序长度会有所增加。程序的长度可能会增加20%~30%。

（四）、程序的受权执行---使用gdb进行调试

使用gdb运行debug3.c程序

编译：\#cc –g –o debug3 debug3.c

调试：\#gdb debug3

(gdb) run

Starting program:/root/course/chapter10/debug3

Program receivedsignal SIGSEGV, Segmentation fault.

0x0804845f in sort(a=0x80497e0, n=5) at debug3.c:23

23      /\* 23  \*/                      if(a\[j\].key >a\[j+1\].key) \{  
可以看到程序停在了debug3.c的第23行

1、栈跟踪---backtrace(缩写为bt)

(gdb) backtrace

\#0  0x0804845f in sort (a=0x80497e0, n=5) atdebug3.c:23

\#1  0x08048573 in main () at debug3.c:37

可以看出sort函数由同一个文件中的main函数在第37行调用的

2、  检查变量

(gdb) print j

$1 = 4         将值4赋给了伪变量$1，后续的命令将输出的结果依次顽抗到保存到$2, $3等中

局部变量j的值是4意味着程序尝试执行的这样的一条指令：

if(a\[4\].key > a\[4+1\].key)

我们传递给sort函数的数组array只有5个元素，它们的下标从0～4，说明这条语句读的是一个不存在的数组元素array\[5\]。循环计数器变量j取了一个错误的值。

打印数组元素中的值

(gdb) print a\[3\]

$3 = \{data ="alex", '\\0' <repeats 4091 times>, key = 1\}

3、  更改源代码----更改后的源程序为debug4.c

将第22行代码由for(j=0; j<n; j++)

更改为：for(j=0; j<n-1; j++)

重新编译debug4.c    \#cc –g –o debug4  debug4.c，编程完成后重新执行：

array\[0\] = \{john, 2\}

array\[1\] = \{alex, 1\}

array\[2\] = \{bill, 3\}

array\[3\] = \{neil, 4\}

array\[4\] = \{rick, 5\}    程序运行仍然不正确

四、调试程序debug4

在sort()函数中有两个循环。外层循环针对每个数组元素执行一次，它的循环计数变量是i。内层循环的作用是交换相邻的两个元素。总的效果是让比较小的元素像“气泡”一样“冒”到数组的顶部。外层循环每执行一次，数组中的最大的元素就会“下沉”到数组的底部。我们可以通过在外层循环中停止此程序的运行并检查数组的状态来核实这一点

1.     设置断点

\#gdb debug4

(gdb) break 22

Breakpoint 1 at0x804841e: file debug4.c, line 22.

2.设置到达断点时显示的内容

(gdb) display array\[0\]@5

3. 设置程序运行到达断点时，显示要查看的数据，然后继续执行

(gdb) commands

Type commands forwhen breakpoint 1 is hit, one per line.

End with a linesaying just "end".

>cont

>end

4、设置完成后运行程序

(gdb) run

Starting program:/root/course/chapter10/debug4

Breakpoint 1, sort (a=0x8049800,n=5) at debug4.c:22

22      /\* 22  \*/              for(j = 0; j < n-1; j++) \{  
1: array\[0\]@5 = \{ \{data ="bill", '\\0' <repeats 4091 times>, key = 3\}, \{  
   data = "neil", '\\0' <repeats 4091 times>, key = 4\}, \{  
   data = "john", '\\0' <repeats 4091 times>, key = 2\}, \{  
   data = "rick", '\\0' <repeats 4091 times>, key = 5\}, \{  
   data = "alex", '\\0' <repeats 4091 times>, key = 1\}\}

Breakpoint 1, sort (a=0x8049800,n=4) at debug4.c:22

22      /\* 22  \*/              for(j = 0; j < n-1; j++) \{  
1: array\[0\]@5 = \{ \{data ="bill", '\\0' <repeats 4091 times>, key = 3\}, \{  
   data = "john", '\\0' <repeats 4091 times>, key = 2\}, \{  
   data = "neil", '\\0' <repeats 4091 times>, key = 4\}, \{  
   data = "alex", '\\0' <repeats 4091 times>, key = 1\}, \{  
   data = "rick", '\\0' <repeats 4091 times>, key = 5\}\}

Breakpoint 1, sort (a=0x8049800,n=3) at debug4.c:22

22      /\* 22  \*/              for(j = 0; j < n-1; j++) \{  
1: array\[0\]@5 = \{ \{data ="john", '\\0' <repeats 4091 times>, key = 2\}, \{  
   data = "bill", '\\0' <repeats 4091 times>, key = 3\}, \{  
   data = "alex", '\\0' <repeats 4091 times>, key = 1\}, \{  
   data = "neil", '\\0' <repeats 4091 times>, key = 4\}, \{  
   data = "rick", '\\0' <repeats 4091 times>, key = 5\}\}

array\[0\] = \{john, 2\}

array\[1\] = \{alex, 1\}

array\[2\] = \{bill, 3\}

array\[3\] = \{neil, 4\}

array\[4\] = \{rick, 5\}

Program exitedwith code 025.   ---不常见的通出码，因为程序本身未调用exit函数，并且也没有从main函数返回一个值，该退出码没有实际意义。

好象

5、用调试器打补丁

用调试器打补丁：通过将断点的设置与相应的操作结合起来来尝试修改程序，而不需要改变程序的源

码和重新编译。

针对debug4，需要在程序的第30行中断程序，增加变量n的值，以使程序执行到第30行时，n的值并未发生变化

重新开始执行这个程序，首先必须删除刚才设置的断点和display命令的内容。可以用info查看曾经设置过的断点及display命令的内容

(gdb) info display

Auto-display expressions now ineffect:

Num Enb Expression

1:   y array\[0\]@5

(gdb) info break

Num    Type           Disp EnbAddress    What

1      breakpoint     keep y   0x08048417 in sort at debug4.c:21

breakpoint already hit 3 times

cont

禁用上述断点与display，可以在今后必要的时候重新启用这些保留的设置

(gdb) disable break 1

(gdb) disable display 1

(gdb) break 30

Breakpoint 2 at0x8048535: file debug4.c, line 30.

(gdb) commands 2

Type commands forwhen breakpoint 2 is hit, one per line.

End with a linesaying just "end".

>set variable n=n+1

>cont

>end

(gdb) run

Starting program:/root/course/chapter10/debug4

Breakpoint 2, sort (a=0x8049800, n=5) atdebug4.c:30

30     /\*  30  \*/              n--;

Breakpoint 2, sort (a=0x8049800, n=5) atdebug4.c:30

30     /\*  30  \*/              n--;

Breakpoint 2, sort (a=0x8049800, n=5) atdebug4.c:30

30     /\*  30  \*/              n--;

Breakpoint 2, sort (a=0x8049800, n=5) atdebug4.c:30

30     /\*  30  \*/              n--;

Breakpoint 2, sort (a=0x8049800, n=5) atdebug4.c:30

30     /\*  30  \*/              n--;

array\[0\] = \{alex, 1\}

array\[1\] = \{john, 2\}

array\[2\] = \{bill, 3\}

array\[3\] = \{neil, 4\}

array\[4\] = \{rick, 5\}

Program exited with code 025.

五、断言

1、断言

在程序的编写过程中，有时系统的内部逻辑需要被确认没有错误。X/Open提供了assert宏，它的作用是测试某个假设是否成立，如果不成立就停止程序的运行

\#include <assert.h>

Void assert (int expression);

assert宏对表达式进行求值，如果结果非零，它就往标准错误写一些诊断信息，然后调用abort函数结束程序的运行。

例：程序assert.c定义了一个函数，它的参数必须是一个正数，它用断来来保护程序不受非法参数的影响

1 \#include <stdio.h>

2 \#include <math.h>

3 \#include <assert.h>

4 \#include <stdlib.h>

6 double my\_sqrt(double x)

7  \{  
     8     assert(x >= 0.0);

9     return sqrt(x);

10  \}

12  int main()

13  \{  
   14      printf("sqrt +2 =%g\\n", my\_sqrt(2.0));

15      printf("sqrt -2 =%g\\n", my\_sqrt(-2.0));

16      exit(0);

17  \}

编译： \# cc -o assert assert.c-lm

执行： \# ./assert

sqrt +2 = 1.41421

assert: assert.c:8: my\_sqrt:Assertion \`x >= 0.0' failed.

Aborted

试图用一个负数来调用函数my\_sqrt时，断言失败了，aasert宏给出了发生断言冲突的文件名和行号，还给出了失败的条件。程序被一个abort中断陷阱终止了运行。这就是assert调用abort的结果

2.    使用-DNDEBUG选项编译

使用-DNDEBUG选项重新编译这个程序，断言功能将被排除在编译结果之外。当在my\_sqrt()中调用sqrt函数时，得到的将是一个NaN(不是一个数字)，表明一个无效结果

编译： \# cc -o assert -DNDEBUG  assert.c-lm

执行： \# ./assert

sqrt +2 = 1.41421

sqrt -2 = nan  
————————————————  
版权声明：本文为CSDN博主「MyAnqi」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。  
原文链接：https://blog.csdn.net/sanganqi\_wusuierzi/article/details/54783958