linux下c++文件编译、多文件编译、gdb调试

骑猪看日落 2022-06-16 12:21 226阅读 0赞

**一. gcc常用编译命令选项**

假设源程序文件名为test.c。

1. 无选项编译链接  
用法：\#gcc test.c  
作用：将test.c预处理、汇编、编译并链接形成可执行文件。这里未指定输出文件，默认输出为a.out。

2. 选项 -o  
用法：\#gcc test.c -o test  
作用：将test.c预处理、汇编、编译并链接形成可执行文件test。-o选项用来指定输出文件的文件名。

3. 选项 -E  
用法：\#gcc -E test.c -o test.i  
作用：将test.c预处理输出test.i文件。

4. 选项 -S  
用法：\#gcc -S test.i  
作用：将预处理输出文件test.i汇编成test.s文件。

5. 选项 -c  
用法：\#gcc -c test.s  
作用：将汇编输出文件test.s编译输出test.o文件。

6. 无选项链接  
用法：\#gcc test.o -o test  
作用：将编译输出文件test.o链接成最终可执行文件test。

7. 选项-O  
用法：\#gcc -O1 test.c -o test  
作用：使用编译优化级别1编译程序。级别为1~3，级别越大优化效果越好，但编译时间越长。

**二. gcc多源文件的编译方法**

如果有多个源文件，基本上有两种编译方法：  
\[假设有两个源文件为test.c和testfun.c\]

1. 多个文件一起编译  
用法：\#gcc testfun.c test.c -o test  
作用：将testfun.c和test.c分别编译后链接成test可执行文件。

2. 分别编译各个源文件，之后对编译后输出的目标文件链接。  
用法：  
\#gcc -c testfun.c //将testfun.c编译成testfun.o  
\#gcc -c test.c //将test.c编译成test.o  
\#gcc -o testfun.o test.o -o test //将testfun.o和test.o链接成test

以上两种方法相比较，第一中方法编译时需要所有文件重新编译，而第二种方法可以只重新编译修改的文件，未修改的文件不用重新编译。

3. 如果要编译的文件都在同一个目录下，可以用通配符gcc \*.c -o 来进行编译。

你是否会问，如果是一个项目的话，可能会有上百个文件，这样的编译法，人不是要累死在电脑前吗，或者等到你编译成功了，岂不是头发都白了，呵呵，所以我们要把上述的编译过程写进以下一个文本文件中：  
Linux下称之为makefile  
  
\#这里可以写一些文件的说明  
MyFirst: MyFirst.o hello.o  
g++ MyFirst.o hello.o -o MyFirst  
Hello.o:Hello.cpp  
g++ -c Hello.cpp -o Hello.o  
MyFirst.o:MyFirst.cpp  
g++ -c MyFirst.cpp -o MyFirst.o  
  
makefile 编写规则：  
（1）以“＃”开始的行为注释  
（2）文件依赖关系为：  
target:components  
rule

存盘为MyFirst，在终端输入：make MyFist

关于makefile的使用，可以参考：http://www.cnblogs.com/wang\_yb/p/3990952.html

**三、gdb常用命令：**

\[root@redhat home\]\#gdb 调试文件：启动gdb

(gdb) l ：（字母l）从第一行开始列出源码

(gdb) break n :在第n行处设置断点

(gdb) break func：在函数func()的入口处设置断点

(gdb) info break： 查看断点信息

(gdb) r：运行程序

(gdb) n：单步执行

(gdb) c：继续运行

(gdb) p 变量 ：打印变量的值

(gdb) bt：查看函数堆栈

(gdb) finish：退出函数

(gdb) shell 命令行：执行shell命令行

(gdb) set args 参数:指定运行时的参数

(gdb) show args：查看设置好的参数

(gdb) show paths:查看程序运行路径；

set environment varname \[=value\] 设置环境变量。如：set env USER=hchen；

show environment \[varname\] 查看环境变量；

(gdb) cd 相当于shell的cd;

(gdb)pwd ：显示当前所在目录

(gdb)info program： 来查看程序的是否在运行，进程号，被暂停的原因。

(gdb)clear 行号n：清除第n行的断点

(gdb)delete 断点号n：删除第n个断点

(gdb)disable 断点号n：暂停第n个断点

(gdb)enable 断点号n：开启第n个断点

(gdb)step：单步调试如果有函数调用，则进入函数；与命令n不同，n是不进入调用的函数的

list ：简记为 l ，其作用就是列出程序的源代码，默认每次显示10行。  
list 行号：将显示当前文件以“行号”为中心的前后10行代码，如：list 12  
list 函数名：将显示“函数名”所在函数的源代码，如：list main  
list ：不带参数，将接着上一次 list 命令的，输出下边的内容。 注意 ：如果运行list 命令得到类似如下的打印，那是因为在编译程序时没有加入 -g 选项：  
(gdb) list  
1 ../sysdeps/i386/elf/start.S: No such file or directory.  
in ../sysdeps/i386/elf/start.S

run：简记为 r ，其作用是运行程序，当遇到断点后，程序会在断点处停止运行，等待用户输入下一步的命令。  
回车：重复上一条命令。  
set args：设置运行程序时的命令行参数，如：set args 33 55  
show args：显示命令行参数  
continue：简讯为 c ，其作用是继续运行被断点中断的程序。  
break：为程序设置断点。  
break 行号：在当前文件的“行号”处设置断点，如：break 33  
break 函数名：在用户定义的函数“函数名”处设置断点，如：break cb\_button  
info breakpoints：显示当前程序的断点设置情况  
disable breakpoints Num：关闭断点“Num”，使其无效，其中“Num”为 info breakpoints 中显示的对应值  
enable breakpoints Num：打开断点“Num”，使其重新生效  
step：简记为 s ，单步跟踪程序，当遇到函数调用时，则进入此函数体（一般只进入用户自定义函数）。  
next：简记为 n，单步跟踪程序，当遇到函数调用时，也不进入此函数体；此命令同 step 的主要区别是，step 遇到用户自定义的函数，将步进到函数中去运行，而 next 则直接调用函数，不会进入到函数体内。  
until：当你厌倦了在一个循环体内单步跟踪时，这个命令可以运行程序直到退出循环体。  
finish： 运行程序，直到当前函数完成返回，并打印函数返回时的堆栈地址和返回值及参数值等信息。  
stepi或nexti：单步跟踪一些机器指令。  
print 表达式：简记为 p ，其中“表达式”可以是任何当前正在被测试程序的有效表达式，比如当前正在调试C语言的程序，那么“表达式”可以是任何C语言的有效表达式，包括数字，变量甚至是函数调用。  
print a：将显示整数 a 的值  
print ++a：将把 a 中的值加1,并显示出来  
print name：将显示字符串 name 的值  
print gdb\_test(22)：将以整数22作为参数调用 gdb\_test() 函数  
print gdb\_test(a)：将以变量 a 作为参数调用 gdb\_test() 函数  
bt：显示当前程序的函数调用堆栈。

display 表达式：在单步运行时将非常有用，使用display命令设置一个表达式后，它将在每次单步进行指令后，紧接着输出被设置的表达式及值。如： display a  
watch 表达式：设置一个监视点，一旦被监视的“表达式”的值改变，gdb将强行终止正在被调试的程序。如： watch a  
kill：将强行终止当前正在调试的程序  
help 命令：help 命令将显示“命令”的常用帮助信息  
call 函数(参数)：调用“函数”，并传递“参数”，如：call gdb\_test(55)  
layout：用于分割窗口，可以一边查看代码，一边测试：  
layout src：显示源代码窗口  
layout asm：显示反汇编窗口  
layout regs：显示源代码/反汇编和CPU寄存器窗口  
layout split：显示源代码和反汇编窗口  
Ctrl + L：刷新窗口  
quit：简记为 q ，退出gdb

**四、gdb 学习小例：**

![复制代码][copycode.gif]

#include <stdio.h>
    
    int add_range(int low, int high)
    {
        int i, sum;
        for (i = low; i <= high; i++)
            sum = sum + i;
        return sum;
    }
    
    int main(void)
    {
        int result[100];
        result[0] = add_range(1, 10);
        result[1] = add_range(1, 100);
        printf("result[0]=%d\nresult[1]=%d\n", result[0], result[1]);
        return 0;
    }

![复制代码][copycode.gif]

`add_range`函数从`low`加到`high`，在`main`函数中首先从1加到10，把结果保存下来，然后从1加到100，再把结果保存下来，最后打印的两个结果是：

result[0]=55
    result[1]=5105

第一个结果正确， 第二个结果显然不正确，在小学我们就听说过高斯小时候的故事，从1加到100应该是5050。一段代码，第一次运行结果是对的，第二次运行却不对，这是很 常见的一类错误现象，这种情况不应该怀疑代码而应该怀疑数据，因为第一次和第二次运行的都是同一段代码，如果代码是错的，那为什么第一次的结果能对呢？然 而第一次和第二次运行时相关的数据却有可能不同，错误的数据会导致错误的结果。在动手调试之前，读者先试试只看代码能不能看出错误原因，只要前面几章学得 扎实就应该能看出来。

在编译时要加上`-g`选项，生成的可执行文件才能用`gdb`进行源码级调试：

$ gcc -g main.c -o main
    $ gdb main
    GNU gdb 6.8-debian
    Copyright (C) 2008 Free Software Foundation, Inc.
    License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html>
    This is free software: you are free to change and redistribute it.
    There is NO WARRANTY, to the extent permitted by law.  Type "show copying"
    and "show warranty" for details.
    This GDB was configured as "i486-linux-gnu"...
    (gdb)

`-g`选项的作用是在可执行文件中加入源代码的信息，比如可执行文件中第几条机器指令对应源代码的第几行，但并不是把整个源文件嵌入到可执行文件中，所以在调试时必须保证`gdb`能找到源文件。`gdb`提供一个类似Shell的命令行环境，上面的`(gdb)`就是提示符，在这个提示符下输入`help`可以查看命令的类别：

(gdb) help
    List of classes of commands:

aliases -- Aliases of other commands
    breakpoints -- Making program stop at certain points
    data -- Examining data
    files -- Specifying and examining files
    internals -- Maintenance commands
    obscure -- Obscure features
    running -- Running the program
    stack -- Examining the stack
    status -- Status inquiries
    support -- Support facilities
    tracepoints -- Tracing of program execution without stopping the program
    user-defined -- User-defined commands
    
    Type "help" followed by a class name for a list of commands in that class.
    Type "help all" for the list of all commands.
    Type "help" followed by command name for full documentation.
    Type "apropos word" to search for commands related to "word".
    Command name abbreviations are allowed if unambiguous.

也可以进一步查看某一类别中有哪些命令，例如查看`files`类别下有哪些命令可用：

(gdb) help files
    Specifying and examining files.
    
    List of commands:

add-shared-symbol-files -- Load the symbols from shared objects in the dynamic linker's link map
    add-symbol-file -- Load symbols from FILE
    add-symbol-file-from-memory -- Load the symbols out of memory from a dynamically loaded object file
    cd -- Set working directory to DIR for debugger and program being debugged
    core-file -- Use FILE as core dump for examining memory and registers
    directory -- Add directory DIR to beginning of search path for source files
    edit -- Edit specified file or function
    exec-file -- Use FILE as program for getting contents of pure memory
    file -- Use FILE as program to be debugged
    forward-search -- Search for regular expression (see regex(3)) from last line listed
    generate-core-file -- Save a core file with the current state of the debugged process
    list -- List specified function or line
    ...

现在试试用`list`命令从第一行开始列出源代码：

(gdb) list 1

1	#include <stdio.h>
    2	
    3	int add_range(int low, int high)
    4	{
    5		int i, sum;
    6		for (i = low; i <= high; i++)
    7			sum = sum + i;
    8		return sum;
    9	}
    10

一次只列10行，如果要从第11行开始继续列源代码可以输入

(gdb) list

也可以什么都不输直接敲回车，`gdb`提供了一个很方便的功能，在提示符下直接敲回车表示重复上一条命令。

(gdb) （直接回车）

11	int main(void)
    12	{
    13		int result[100];
    14		result[0] = add_range(1, 10);
    15		result[1] = add_range(1, 100);
    16		printf("result[0]=%d\nresult[1]=%d\n", result[0], result[1]);
    17		return 0;
    18

`gdb`的很多常用命令有简写形式，例如`list`命令可以写成`l`，要列一个函数的源代码也可以用函数名做参数：

(gdb) l add_range
    1	#include <stdio.h>
    2	
    3	int add_range(int low, int high)
    4	{
    5		int i, sum;
    6		for (i = low; i <= high; i++)
    7			sum = sum + i;
    8		return sum;
    9	}
    10

现在退出`gdb`的环境：

(gdb) quit

我们做一个实验，把源代码改名或移到别处再用`gdb`调试，这样就列不出源代码了：

$ mv main.c mian.c
    $ gdb main
    ...
    (gdb) l
    5	main.c: No such file or directory.
    	in main.c

可见`gcc`的`-g`选项并不是把源代码嵌入到可执行文件中的，在调试时也需要源文件。现在把源代码恢复原样，我们继续调试。首先用`start`命令开始执行程序：

$ gdb main
    ...
    (gdb) start
    Breakpoint 1 at 0x80483ad: file main.c, line 14.
    Starting program: /home/akaedu/main 
    main () at main.c:14
    14		result[0] = add_range(1, 10);
    (gdb)

`gdb`停在`main`函数中变量定义之后的第一条语句处等待我们发命令，`gdb`列出的这条语句是即将执行的下一条语句。我们可以用`next`命令（简写为`n`）控制这些语句一条一条地执行：

(gdb) n
    15		result[1] = add_range(1, 100);
    (gdb) （直接回车）
    16		printf("result[0]=%d\nresult[1]=%d\n", result[0], result[1]);
    (gdb) （直接回车）

result[0]=55
    result[1]=5105
    17		return 0;

用`n`命令依次执行两行赋值语句和一行打印语句，在执行打印语句时结果立刻打出来了，然后停在`return`语句之前等待我们发命令。虽然我们完全控制了程序的执行，但仍然看不出哪里错了，因为错误不在`main`函数中而在`add_range`函数中，现在用`start`命令重新来过，这次用`step`命令（简写为`s`）钻进`add_range`函数中去跟踪执行：

(gdb) start
    The program being debugged has been started already.
    Start it from the beginning? (y or n) y
    
    Breakpoint 2 at 0x80483ad: file main.c, line 14.
    Starting program: /home/akaedu/main 
    main () at main.c:14
    14		result[0] = add_range(1, 10);
    (gdb) s
    add_range (low=1, high=10) at main.c:6
    6		for (i = low; i <= high; i++)

这次停在了`add_range`函数中变量定义之后的第一条语句处。在函数中有几种查看状态的办法，`backtrace`命令（简写为`bt`）可以查看函数调用的栈帧：

(gdb) bt
    #0  add_range (low=1, high=10) at main.c:6
    #1  0x080483c1 in main () at main.c:14

可见当前的`add_range`函数是被`main`函数调用的，`main`传进来的参数是`low=1, high=10`。`main`函数的栈帧编号为1，`add_range`的栈帧编号为0。现在可以用`info`命令（简写为`i`）查看`add_range`函数局部变量的值：

(gdb) i locals

i = 0
    sum = 0

如果想查看`main`函数当前局部变量的值也可以做到，先用`frame`命令（简写为`f`）选择1号栈帧然后再查看局部变量：

(gdb) f 1
    #1  0x080483c1 in main () at main.c:14
    14		result[0] = add_range(1, 10);
    (gdb) i locals 
    result = {0, 0, 0, 0, 0, 0, 134513196, 225011984, -1208685768, -1081160480, 
    ...
      -1208623680}

注意到`result`数组中有很多元素具有杂乱无章的值，我们知道未经初始化的局部变量具有不确定的值。到目前为止一切正常。用`s`或`n`往下走几步，然后用`print`命令（简写为`p`）打印出变量`sum`的值：

(gdb) s
    7			sum = sum + i;
    (gdb) （直接回车）
    6		for (i = low; i <= high; i++)
    (gdb) （直接回车）
    7			sum = sum + i;
    (gdb) （直接回车）
    6		for (i = low; i <= high; i++)
    (gdb) p sum
    $1 = 3

第一次循环`i`是1，第二次循环`i`是2，加起来是3，没错。这里的`$1`表示`gdb`保存着这些中间结果，$后面的编号会自动增长，在命令中可以用`$1`、`$2`、`$3`等编号代替相应的值。由于我们本来就知道第一次调用的结果是正确的，再往下跟也没意义了，可以用`finish`命令让程序一直运行到从当前函数返回为止：

(gdb) finish
    Run till exit from #0  add_range (low=1, high=10) at main.c:6
    0x080483c1 in main () at main.c:14
    14		result[0] = add_range(1, 10);
    Value returned is $2 = 55

返回值是55，当前正准备执行赋值操作，用`s`命令赋值，然后查看`result`数组：

(gdb) s
    15		result[1] = add_range(1, 100);
    (gdb) p result
    $3 = {55, 0, 0, 0, 0, 0, 134513196, 225011984, -1208685768, -1081160480, 
    ...
      -1208623680}

第一个值55确实赋给了`result`数组的第0个元素。下面用`s`命令进入第二次`add_range`调用，进入之后首先查看参数和局部变量：

(gdb) s
    add_range (low=1, high=100) at main.c:6
    6		for (i = low; i <= high; i++)
    (gdb) bt
    #0  add_range (low=1, high=100) at main.c:6
    #1  0x080483db in main () at main.c:15
    (gdb) i locals 
    i = 11
    sum = 55

由于局部变量`i`和`sum`没初始化，所以具有不确定的值，又由于两次调用是挨着的，`i`和`sum`正好取了上次调用时的值。`i`的初值不是0倒没关系，在`for`循环中会赋值为0的，但`sum`如果初值不是0，累加得到的结果就错了。好了，我们已经找到错误原因，可以退出`gdb`修改源代码了。如果我们不想浪费这次调试机会，可以在`gdb`中马上把`sum`的初值改为0继续运行，看看这一处改了之后还有没有别的Bug：

(gdb) set var sum=0
    (gdb) finish
    Run till exit from #0  add_range (low=1, high=100) at main.c:6
    0x080483db in main () at main.c:15
    15		result[1] = add_range(1, 100);
    Value returned is $4 = 5050
    (gdb) n
    16		printf("result[0]=%d\nresult[1]=%d\n", result[0], result[1]);
    (gdb) （直接回车）
    result[0]=55
    result[1]=5050
    17		return 0;

这样结果就对了。修改变量的值除了用`set`命令之外也可以用`print`命令，因为`print`命令后面跟的是表达式，而我们知道赋值和函数调用也都是表达式，所以也可以用`print`命令修改变量的值或者调用函数：

(gdb) p result\[2\]=33  
　$5 = 33  
　(gdb) p printf("result\[2\]=%d\\n", result\[2\])  
　result\[2\]=33  
　$6 = 13

**五、多线程调试**  
1. 多线程调试,最重要的几个命令:  
info threads 查看当前进程的线程。  
GDB会为每个线程分配一个ID, 后面操作线程的时候会用到这个ID.  
前面有\*的是当前调试的线程.  
thread <ID> 切换调试的线程为指定ID的线程。  
break file.c:100 thread all 在file.c文件第100行处为所有经过这里的线程设置断点。  
set scheduler-locking off|on|step  
在使用step或者continue命令调试当前被调试线程的时候，其他线程也是同时执行的,  
怎么只让被调试程序执行呢？  
通过这个命令就可以实现这个需求。  
off 不锁定任何线程，也就是所有线程都执行，这是默认值。  
on 只有当前被调试程序会执行。  
step 在单步的时候，除了next过一个函数的情况  
(熟悉情况的人可能知道，这其实是一个设置断点然后continue的行为)以外，  
只有当前线程会执行。  
thread apply ID1 ID2 command 让一个或者多个线程执行GDB命令command  
thread apply all command 让所有被调试线程执行GDB命令command。  
  
2. 使用示例:  
线程产生通知：在产生新的线程时, gdb会给出提示信息  
(gdb) r  
Starting program: /root/thread  
\[New Thread 1073951360 (LWP 12900)\]  
\[New Thread 1082342592 (LWP 12907)\]---以下三个为新产生的线程  
\[New Thread 1090731072 (LWP 12908)\]  
\[New Thread 1099119552 (LWP 12909)\]  
  
查看线程：使用info threads可以查看运行的线程。  
(gdb) info threads  
4 Thread 1099119552 (LWP 12940) 0xffffe002 in ?? ()  
3 Thread 1090731072 (LWP 12939) 0xffffe002 in ?? ()  
2 Thread 1082342592 (LWP 12938) 0xffffe002 in ?? ()  
\* 1 Thread 1073951360 (LWP 12931) main (argc=1, argv=0xbfffda04) at thread.c:21  
(gdb)  
注意，行首为gdb分配的线程ID号，对线程进行切换时，使用该ID号码。  
另外，行首的星号标识了当前活动的线程  
切换线程：  
使用 thread THREADNUMBER 进行切换，THREADNUMBER 为上文提到的线程ID号。  
下例显示将活动线程从 1 切换至 4。  
(gdb) info threads  
4 Thread 1099119552 (LWP 12940) 0xffffe002 in ?? ()  
3 Thread 1090731072 (LWP 12939) 0xffffe002 in ?? ()  
2 Thread 1082342592 (LWP 12938) 0xffffe002 in ?? ()  
\* 1 Thread 1073951360 (LWP 12931) main (argc=1, argv=0xbfffda04) at thread.c:21  
(gdb) thread 4  
\[Switching to thread 4 (Thread 1099119552 (LWP 12940))\]\#0 0xffffe002 in ?? ()  
(gdb) info threads  
\* 4 Thread 1099119552 (LWP 12940) 0xffffe002 in ?? ()  
3 Thread 1090731072 (LWP 12939) 0xffffe002 in ?? ()  
2 Thread 1082342592 (LWP 12938) 0xffffe002 in ?? ()  
1 Thread 1073951360 (LWP 12931) main (argc=1, argv=0xbfffda04) at thread.c:21  
(gdb)  
以上即为使用gdb提供的对多线程进行调试的一些基本命令。  
另外，gdb也提供对线程的断点设置以及对指定或所有线程发布命令的命令  
  
**六、调试宏**  
在GDB下, 我们无法print宏定义，因为宏是预编译的。  
但是我们还是有办法来调试宏，这个需要GCC的配合。  
在GCC编译程序的时候，加上  
 **-ggdb3** 参数，这样，你就可以调试宏了。  
  
另外，你可以使用下述的GDB的宏调试命令 来查看相关的宏。  
info macro 查看这个宏在哪些文件里被引用了，以及宏定义是什么样的。  
macro 查看宏展开的样子。  
  
**七、源文件**  
GDB时,提示找不到源文件。  
需要做下面的检查:  
编译程序员是否加上了 -g参数 以包含debug信息。  
路径是否设置正确了。  
使用GDB的directory命令来设置源文件的目录。  
  
下面给一个调试/bin/ls的示例(ubuntu下)  
$ apt-get source coreutils  
$ sudo apt-get install coreutils-dbgsym  
$ gdb /bin/ls  
GNU gdb (GDB) 7.1-ubuntu  
(gdb) list main  
1192 ls.c: No such file or directory.  
in ls.c  
(gdb) directory ~/src/coreutils-7.4/src/  
Source directories searched: /home/hchen/src/coreutils-7.4:cdir: cdir:cwd  
(gdb) list main  
1192 \}  
1193 \}  
1194  
1195 int  
1196 main (int argc, char \*\*argv)  
1197 \{  
1198 int i;  
1199 struct pending \*thispend;  
1200 int n\_files;  
1201  
  
**八、条件断点**  
条件断点是语法是：  
break \[where\] if \[condition\]  
这种断点真是非常管用。  
尤其是在一个循环或递归中，或是要监视某个变量。  
注意，这个设置是在GDB中的，只不过每经过那个断点时GDB会帮你检查一下条件是否满足。  
  
**九、命令行参数**  
有时候，我们需要调试的程序需要有命令行参数, 有三种方法：  
gdb命令行的 -args 参数  
gdb环境中 set args命令。  
gdb环境中 run 参数  
  
**十、gdb的变量**  
有时候，在调试程序时，我们不单单只是查看运行时的变量，  
我们还可以直接设置程序中的变量，以模拟一些很难在测试中出现的情况，比较一些出错，  
或是switch的分支语句。使用set命令可以修改程序中的变量。  
另外，你知道gdb中也可以有变量吗？  
就像shell一样，gdb中的变量以$开头，比如你想打印一个数组中的个个元素，你可以这样：  
(gdb) set $i = 0  
(gdb) p a\[$i++\]  
... \#然后就一路回车下去了  
当然，这里只是给一个示例，表示程序的变量和gdb的变量是可以交互的。  
  
**十一、x命令**  
也许，你很喜欢用p命令。  
所以，当你不知道变量名的时候，你可能会手足无措，因为p命令总是需要一个变量名的。  
x命令是用来查看内存的，在gdb中 “help x” 你可以查看其帮助。  
x/x 以十六进制输出  
x/d 以十进制输出  
x/c 以单字符输出  
x/i 反汇编 – 通常，我们会使用 x/10i ip−20来查看当前的汇编（ ip−20来查看当前的汇编（ip是指令寄存器）  
x/s 以字符串输出  
  
**十二、command命令**  
如何自动化调试。  
这里向大家介绍command命令，简单的理解一下，其就是把一组gdb的命令打包，有点像字处理软件的“宏”。  
下面是一个示例：  
(gdb) break func  
Breakpoint 1 at 0x3475678: file test.c, line 12.  
(gdb) command 1  
Type commands for when breakpoint 1 is hit, one per line.  
End with a line saying just "end".  
>print arg1  
>print arg2  
>print arg3  
>end  
(gdb)  
当我们的断点到达时，自动执行command中的三个命令，把func的三个参数值打出来。

[copycode.gif]: /images/20220616/d8184869505f428a9913bbf39a24c3f5.png