如何在Linux中使用gdb调试C程序

合集下载

GDB调试简易教程

GDB调试简易教程GDB（GNU调试器）是一个开源的调试工具，它用于调试C、C++和其他编程语言的程序。

它允许程序员在执行过程中观察程序的内部状态，帮助找到程序中的错误并进行修复。

下面是一个简易的GDB调试教程，以帮助你入门并学会使用它。

安装GDB首先，你需要在你的系统上安装GDB。

对于大多数Linux发行版，你可以通过在终端中运行以下命令来安装它：```sudo apt-get install gdb```编译程序在使用GDB之前，你需要编译你的程序，并在编译时使用-g选项，以便生成调试信息。

例如，对于C语言程序，你可以使用以下命令来编译：```gcc -g program.c -o program```这将生成一个可执行文件program，并在目录中生成调试信息。

启动GDB在终端中使用以下命令来启动GDB并调试你的程序：```gdb program```这将启动GDB，并且你将看到GDB的命令提示符。

设置断点断点是你在程序中指定的一个位置，当程序执行到该位置时会暂停。

你可以使用断点来观察程序在这一点的状态。

要设置断点，请在GDB的命令提示符下输入以下命令：```break line_number```line_number是你想要设置断点的源代码行号。

例如，要在程序的第10行设置断点，你可以使用以下命令：```break 10```或者你也可以使用函数名作为参数来设置断点：```break function_name```开始调试一旦设置好断点，你可以开始调试你的程序了。

要开始执行程序，请输入以下命令：```run```程序将开始运行直到第一个断点处。

此时，程序会停下来并且GDB会等待你的进一步命令。

观察变量在程序运行到断点处时，你可以使用以下命令来观察程序内部的变量值：```print variable_name```variable_name是你想要观察的变量的名称。

例如，要查看变量x的值，你可以使用以下命令：```print x```你还可以通过使用其他GDB命令来观察更多的变量信息，例如观察数组、结构体等。

利用GDB调试器调试C程序详细图解

利用GDB调试器调试C程序详细图解一、利用GDB调试器对C程序进行调试。

1、在Linux终端下，利用命令行将当前目录切换到/usr、并在此路径下新建文件夹gdb_src，在目录/usr/gdb_src下编辑C语言源程序GDB_test.c，具体指令如图1：图12、C语言源程序GDB_test.c内容如图2：图23、在程序编译时加入调试选项-g，表明使用GDB调试器对上述程序进行调试，命令如图3：图34、启动GDB，开始程序的调试，命令如图4：图45、使用指令“list”显示源代码，l相当于list指令，如图5：图56、在源程序中第10行设置断点，如图6：图67、在源程序中print函数处设置断点，如图7：图78、使用“info”指令显示断点信息，如图8：图89、使用“run”指令运行程序，r相当于run指令，如图8：图910、程序在第一个断点处停止，使用“next”指令单步运行程序，n相当于next 指令，如图10：图1011、再使用“next”指令单步运行程序，如图11：图1112、使用“print”指令输出变量i的值，如图12：图1213、使用“continue”指令让程序继续执行，c相当于continue，如图13：图1314、再使用“continue”指令让程序继续执行，程序运行结束，如图13：图1415、退出GDB调试器，如图15：图15二、利用GDB调试器对下列程序进行调试，找出程序错误之处，并改正、运行，在屏幕上显示出正确结果，要求将在Linux 的终端中的调试过程屏幕截图以供验收。

1、原程序指令如图1：图1参考资料：1、Linux包含一个叫GDB的GNU调试程序，GDB是一个用来调试C和C++语言程序的调试器，并能在程序运行时观察程序的内部结构和内存的使用情况，具体GDB基本命令见文档“GDB基本命令集”；2、一般来说，GDB提供如下功能：（1）启动程序，按照程序员自定义的要求运行程序；（2）单步执行、设置断点，以使程序在指定的断点代码上停止执行；（3）监视程序中变量的值和其他发生的事情；（4）动态改变程序的执行环境。

Linux命令高级技巧使用gdb命令进行程序的调试与分析

Linux命令高级技巧使用gdb命令进行程序的调试与分析在Linux环境下，gdb（GNU调试器）是一个非常强大的工具，用于调试和分析程序的运行。

它提供了丰富的功能，能够帮助开发人员定位和解决程序中的错误。

本文将介绍一些使用gdb命令进行程序调试与分析的高级技巧。

一、安装gdb命令若系统中尚未安装gdb命令，可以通过以下方式安装：1. 打开终端窗口2. 输入命令“sudo apt-get install gdb”并按下回车键3. 输入用户密码并按下回车键4. 等待安装完成二、使用gdb调试程序调试程序是开发过程中非常重要的一环。

gdb提供了各种功能，可以帮助开发人员追踪代码的执行，查找变量的值，以及定位程序中的错误。

下面介绍一些常用的调试命令：1. 启动gdb调试使用命令“gdb <可执行文件>”启动gdb调试器，其中<可执行文件>是需要调试的程序的路径和文件名。

2. 设置断点在需要设置断点的代码行前面输入“break”命令，例如“break main”，即可在main函数入口处设置断点。

使用命令“info breakpoints”可以查看已设置的断点。

3. 运行程序输入“run”命令，即可开始运行程序。

程序运行到断点处会自动停止，等待用户进行调试操作。

4. 单步执行输入“next”命令可逐行执行程序，遇到函数调用时会直接跳过，并进入下一行。

若想进入函数内部进行调试，使用“step”命令。

5. 查看变量值使用“print <变量名>”命令可以查看变量的值，例如“print num”即可查看名为num的变量的值。

6. 修改变量值输入“set <变量名>=<新值>”命令可以修改变量的值，例如“setnum=10”即可将名为num的变量的值修改为10。

7. 继续执行使用“continue”命令可以让程序继续执行，直到遇到下一个断点或程序结束。

使用GDB进行程序调试

使用GDB进行程序调试GDB（GNU Debugger）是一个功能强大的调试工具，可以帮助程序员找到和解决程序中的错误。

它支持多种编程语言，包括C，C++，Fortran 等，并且可以在多种操作系统上运行，如Linux，MacOS和Windows。

下面是使用GDB进行程序调试的一般步骤：1. 编译程序时添加调试信息：在使用GDB进行程序调试之前，我们需要在编译程序时添加调试信息。

在GCC编译器中，可以通过使用`-g`选项来实现。

例如，`gcc -g my_program.c -o my_program`。

2. 启动GDB：以调试模式启动GDB，可以通过在终端中输入`gdb`命令来启动GDB。

然后，使用`file`命令加载要调试的可执行文件。

例如，`file my_program`。

3. 设置断点：在代码中设置断点，GDB会在断点处停止执行程序。

可以使用`break`命令来设置断点。

例如，`break main`会在程序开始执行时停止在`main`函数的第一行。

4. 运行程序：使用`run`命令来运行程序。

GDB会启动程序，并在遇到断点时停止。

可以使用`continue`命令继续执行程序。

5. 调试程序：一旦程序停止在断点处，可以使用一些GDB命令来检查变量的值，跟踪程序执行流程等。

例如，使用`print`命令来打印变量的值，使用`step`命令来单步执行程序，使用`next`命令将执行一行代码，而不会深入到函数内部。

6. 回顾栈帧：GDB允许回顾程序调用栈上的栈帧信息。

可以使用`backtrace`命令来打印当前调用栈上所有活动栈帧的信息。

使用`frame`命令可以切换到任一栈帧。

7. 调试崩溃：如果程序崩溃了，GDB将会在崩溃发生时停止程序并提供一些有关崩溃原因的信息。

通过使用`bt`命令可以获得崩溃时的调用栈信息。

8. 再次运行：如果在调试过程中发现问题已经解决，可以使用`kill`命令停止程序的执行，并使用`run`命令重新运行程序。

linux C- gdb调试、Makefile

linux C－gdb调试、Makefilegcc可以编译c, c++, object-c, java等众多的语言程序g++则是专注于Ｃ和C++。

gdb调试GDB 调试器是一个功能强大的工具，它可以做很多的调试工作，如断点，单步跟踪等。

相关命令:下面演示两个例子，追踪快速排序的过程和查看优化后的gcd()算法（方法来自编程之美)观察快速排序：打印数组，查看快速排序中各个元素的位置变化源码：#include <stdio.h>#include <algorithm>using namespace std;int partion(int a[],int start,int end){int i=start,j=end;int temp=a[start];while(i<j){while(i<j && a[j]>=temp) j--;a[i]=a[j]; // i are morewhile(i<j && a[i]<=temp) i++;a[j]=a[i]; // j are more}a[i]=temp; // at end , i=jreturn i;}void Qsort(int a[],int start,int end){if(start<end){int d=partion(a,start,end);Qsort(a,start,d);Qsort(a,d+1,end);}}int main(){int a[10]={3,2,7,5,1,0,9,6,4,11};Qsort(a,0,9);for(int i=0;i<10;i++)printf("%d ",a[i]);printf("\n");return 0;}指令：edemon@linux:~$ g++ -g -o exe main.cppedemon@linux:~$ gdb exe(gdb) break 17Breakpoint 1 at 0x4006f4: file main.cpp, line 17.(gdb) runBreakpoint 1, Qsort (a=0x7fffffffdda0, start=0, end=9) at main.cpp:17 17 if(start<end){(gdb) p *a@10$2 = {3, 2, 7, 5, 1, 0, 9, 6, 4, 11}(gdb) continueBreakpoint 1, Qsort (a=0x7fffffffdda0, start=0, end=3) at main.cpp:17 17 if(start<end){(gdb) p *a@10$3 = {0, 2, 1, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=0, end=0) at main.cpp:17 17 if(start<end){(gdb) p *a@10$4 = {0, 2, 1, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=1, end=3) at main.cpp:17 17 if(start<end){(gdb) p *a@10$5 = {0, 2, 1, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=1, end=2) at main.cpp:17 17 if(start<end){(gdb) p *a@10$6 = {0, 1, 2, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=1, end=1) at main.cpp:17 17 if(start<end){(gdb) p *a@10$7 = {0, 1, 2, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=2, end=2) at main.cpp:17 17 if(start<end){(gdb) p *a@10$8 = {0, 1, 2, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=3, end=3) at main.cpp:17 17 if(start<end){(gdb) p *a@10$9 = {0, 1, 2, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=4, end=9) at main.cpp:17 17 if(start<end){(gdb) p *a@10$10 = {0, 1, 2, 3, 5, 7, 9, 6, 4, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=4, end=5) at main.cpp:17 17 if(start<end){(gdb) p *a@10$11 = {0, 1, 2, 3, 4, 5, 9, 6, 7, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=4, end=4) at main.cpp:17 17 if(start<end){(gdb) p *a@10$12 = {0, 1, 2, 3, 4, 5, 9, 6, 7, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=5, end=5) at main.cpp:17 17 if(start<end){(gdb) p *a@10$13 = {0, 1, 2, 3, 4, 5, 9, 6, 7, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=6, end=9) at main.cpp:17 17 if(start<end){(gdb) p *a@10$14 = {0, 1, 2, 3, 4, 5, 9, 6, 7, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=6, end=8) at main.cpp:17 17 if(start<end){(gdb) p *a@10$15 = {0, 1, 2, 3, 4, 5, 7, 6, 9, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=6, end=7) at main.cpp:17 17 if(start<end){(gdb) p *a@10$16 = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=6, end=6) at main.cpp:17 17 if(start<end){(gdb) p *a@10$17 = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=7, end=7) at main.cpp:17 17 if(start<end){(gdb) p *a@10$18 = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=8, end=8) at main.cpp:17 17 if(start<end){(gdb) p *a@10$19 = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11}(gdb) continueContinuing.Breakpoint 1, Qsort (a=0x7fffffffdda0, start=9, end=9) at main.cpp:17 17 if(start<end){(gdb) p *a@10$20 = {0, 1, 2, 3, 4, 5, 6, 7, 9, 11}(gdb) continueContinuing.0 1 2 3 4 5 6 7 9 11[Inferior 1 (process 7467) exited normally]计算24, 26的最大公约数:使用gdb查看递归情况，a和ｂ是怎样变化的。

linux下C语言使用编译与调试试验

u
撤消
·
重做
2、GNU C编译器
1)使用gcc
通常后跟一些选项和文件名来使用gcc编译器。gcc命令的基本用法如下：
gcc [options] []
命令行选项指定的编译过程中的具体操作
2) gcc常用选项
当不用任何选项编译一个程序时，gcc将建立（假定编译成功）一个名为a.out的可执行文件。
选项含义：
{ห้องสมุดไป่ตู้
printf("Usage:pow base exponent\n");
exit(1);
}
res = mypow(x, y);
printf("%u ^ %u = %u\n", x, y, res);
return 0;
}
编译过程：
# gcc -c mypow.c
# ar rcsv libpow.a mypow.o
此时得到的可执行文件就不再是a.out，而是count。
-c GCC仅把源代码编译为目标代码。默认时GCC建立的目标代码文件有一个.o的
扩展名。
-E对文件进行预处理
-S对文件进行编译，生成汇编代码。
-O对源代码进行基本优化。这些优化在大多数情况下都会使程序执行得更快。
-g在可执行程序中包含标准调试信息。
-Wall允许发出GCC能提供的所有有用的警告，也可以用-W(warning)来标识指定的
警告。
-lname链接静态库
-Ldir库文件的搜索路径
3)执行文件
格式：./可执行文件名
例：
# ./a.out
# ./count
4)例子
mypow.c：定义mypow()函数

如何在Linux终端中调试程序

如何在Linux终端中调试程序在Linux系统中，终端是开发者和系统管理员经常使用的重要工具。

通过终端，我们可以执行各种命令和操作，包括程序的编译、运行和调试。

本文将介绍在Linux终端中如何进行程序调试的方法和技巧。

一、安装调试工具要在Linux终端中进行程序调试，首先需要安装相应的调试工具。

常用的调试工具包括GDB (GNU调试器)和LLDB (LLVM调试器)。

这两个工具都是开源的，可以通过包管理器来安装。

1. 使用GDB进行程序调试GDB是Linux中最常用的调试工具之一。

下面是GDB的安装方法：```$ sudo apt-get install gdb```安装完成后，可以通过以下命令来验证安装是否成功：```$ gdb --version```2. 使用LLDB进行程序调试LLDB是一个高级的调试工具，它可以用于多种编程语言，包括C、C++和Objective-C。

下面是LLDB的安装方法：```$ sudo apt-get install lldb```安装完成后，可以通过以下命令来验证安装是否成功：```$ lldb --version```二、编译程序时的调试选项在Linux终端中调试程序时，为了方便跟踪问题和定位错误，可以在编译程序时添加调试选项。

常用的调试选项包括-g（生成调试信息）、-Wall（显示警告信息）和-O0（禁用优化）。

例如，使用gcc编译C程序时可以使用以下命令：```$ gcc -g -Wall -O0 program.c -o program```三、使用GDB进行程序调试1. 启动GDB调试器通过以下命令启动GDB调试器，并加载需要调试的程序：```$ gdb program```2. 设置断点在GDB中，可以使用break命令设置断点，以便在程序执行到指定位置时暂停。

例如，要在函数的第10行设置断点，可以使用以下命令：```(gdb) break 10```3. 执行程序使用run命令执行程序，并在断点处停止：```(gdb) run```4. 调试程序一旦程序在断点处停止，可以使用以下命令进行调试：- 继续执行：使用continue命令继续执行程序。

使用GDB命令行调试器调试C-C++程序

使用GDB命令行调试器调试C/C++程序
没有调试器的情况下编写程序时最糟糕的状况是什么？编译时跪着祈祷不要出错？用血祭召唤恶魔帮你运行程序？或者在每一行代码间添加printf("test")语句来定位错误点？如你所知，编写程序时不使用调试器的话是不方便的。

幸好，linux下调试还是很方便的。

大多数人使用的IDE都集成了调试器，但linux 最著名的调试器是命令行形式的C/C++调试器GDB。

然而，与其他命令行工具一致，DGB需要一定的练习才能完全掌握。

这里，我会告诉你GDB的基本情况及使用方法。

安装GDB
大多数的发行版仓库中都有GDB
Debian 或Ubuntu
$ sudo apt-get install gdb
Arch Linux
$ sudo pacman -S gdb
Fedora,CentOS 或RHEL：
$sudo yum install gdb
如果在仓库中找不到的话，可以从官网中下载。

示例代码
当学习GDB时，最好有一份代码，动手试验。

下列代码是我编写的简单例子，它可以很好的体现GDB的特性。

将它拷贝下来并且进行实验——这是最好的方法。

#include
#include
int main(int argc,char**argv)
{
int i;
int a=0, b=0, c=0;
double d;。

linux下的C语言开发(gdb调试)

联系信箱：feixiaoxing @】编写代码过程中少不了调试。

在windows下面，我们有visual studio工具。

在linux下面呢，实际上除了gdb 工具之外，你没有别的选择。

那么，怎么用gdb进行调试呢？我们可以一步一步来试试看。

既然需要调试，那么生成的可执行文件就需要包含调试的信息，这里应该怎么做呢？很简单，输入gcc test.c -g -o test。

输入命令之后，如果没有编译和链接方面的错误，你就可以看到可执行文件test了。

调试的步骤基本如下所示，（01）首先，输入gdb test（02）进入到gdb的调试界面之后，输入list，即可看到test.c源文件（03）设置断点，输入b main（04）启动test程序，输入run（05）程序在main开始的地方设置了断点，所以程序在printf处断住（06）这时候，可以单步跟踪。

s单步可以进入到函数，而n单步则越过函数（07）如果希望从断点处继续运行程序，输入c（08）希望程序运行到函数结束，输入finish（09）查看断点信息，输入info break（10）如果希望查看堆栈信息，输入bt（11）希望查看内存，输入x/64xh + 内存地址（12）删除断点，则输入delete break + 断点序号（13）希望查看函数局部变量的数值，可以输入print + 变量名（14）希望修改内存值，直接输入print + *地址= 数值（15）希望实时打印变量的数值，可以输入display + 变量名（16）查看函数的汇编代码，输入disassemble + 函数名（17）退出调试输入quit即可。

Linux命令高级技巧使用gdb和valgrind进行内存调试和分析

Linux命令高级技巧使用gdb和valgrind进行内存调试和分析在Linux系统中，gdb和valgrind是两个常用的工具，用于进行程序的内存调试和分析。

本文将介绍如何使用gdb和valgrind进行高级技巧的相关操作和使用方法。

一、gdb内存调试技巧1. 编译程序时加入调试信息在进行程序编译时，可以添加-g参数，以便在调试时获取符号表信息。

例如：```gcc -g myprogram.c -o myprogram```2. 启动gdb调试程序在终端中输入下列命令启动gdb，并加载待调试的程序：```gdb myprogram```3. 设置断点使用break命令设置断点，指定程序执行到特定位置时停下来。

例如，在第10行设置断点：```break 10```4. 运行程序输入run命令以运行程序。

程序将会在设置的断点处停下来。

可以通过step或next命令逐行执行程序。

5. 输出变量值在断点停下来时，可以使用print命令打印出变量的值。

例如：```print variable```6. 监测内存错误使用GNU debugger的功能来检查内存错误和泄漏。

使用valgrind 可以检测到许多内存相关的问题。

二、valgrind内存分析技巧1. 安装valgrind在Linux系统中，可以使用包管理工具安装valgrind。

例如，在Ubuntu系统中，可以使用以下命令安装valgrind：```sudo apt-get install valgrind```2. 运行valgrind在终端中输入以下命令来运行valgrind：```valgrind --tool=memcheck ./myprogram```其中，myprogram为待分析的程序。

3. 查找内存错误valgrind将会分析程序的内存使用情况，并输出相关的错误信息。

特别是当程序存在内存泄漏时，valgrind将会给出相应的提示。

linux系统调试工具GDB 命令详细解释..

Linux中包含有一个很有用的调试工具－－gdb(GNU Debuger)，它可以用来调试C和C++程序，功能不亚于Windows下的许多图形界面的调试工具。

和所有常用的调试工具一样，gdb提供了以下功能：# 监视程序中变量的值# 在程序中设置断点# 程序的单步执行在使用gdb前，必须先载入可执行文件，因为要进行调试，文件中就必须包含调试信息，所以在用gcc或cc编译时就需要用-g参数来打开程序的调试选项。

调试开始时，必须先载入要进行调试的程序，可以用以下两种方式：* 在启动gdb后执行以下命令：file 可执行文件路径* 在gdb启动时就载入程序：gdb 可执行文件路径载入程序后，接下来就是要进行断点的设置，要监视的变量的添加等工作，下面对在这个过程中常会用到的命令逐一进行介绍：* list：显示程序中的代码，常用使用格式有：list输出从上次调用list命令开始往后的10行程序代码。

list -输出从上次调用list命令开始往前的10行程序代码。

list n输出第n行附近的10行程序代码。

list function输出函数function前后的10行程序代码。

* forward/search：从当前行向后查找匹配某个字符串的程序行。

使用格式：forward/search 字符串查找到的行号将保存在$_变量中，可以用print $_命令来查看。

* reverse-search：和forward/search相反，向前查找字符串。

使用格式同上。

* break：在程序中设置断点，当程序运行到指定行上时，会暂停执行。

使用格式：break 要设置断点的行号* tbreak：设置临时断点，在设置之后只起作用一次。

使用格式：tbreak 要设置临时断点的行号* clear：和break相反，clear用于清除断点。

使用格式：clear 要清除的断点所在的行号* run：启动程序，在run后面带上参数可以传递给正在调试的程序。

怎么用gdb工具调试Linux c

$ 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);
stack -- Examining the stack
status -- Status inquiries
support -- Support facilities
tracepoints -- Tracing of program execution without
stopping the program
第 10 章 gdb
目录
1. 单步执行和跟踪函数调用
2. 断点
3. 观察点
4. 段错误
程序中除了一目了然的Bug之外都需要一定的调试手段来分析到底错在哪。到
目前为止我们的调试手段只有一种：根据程序执行时的出错现象假设错误原因，
然后在代码中适当的位置插入printf，执行程序并分析打印结果，如果结果和
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;
result[1]);
17 return 0;

Linux下C程序的GDB调试方法

调试Linux下的C程序GDB是GNU开源组织发布的一个强大的UNIX下的程序调试工具。

或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在UNIX平台下做软件，你会发现GDB这个调试工具有比VC、BCB的图形化调试器更强大的功能。

所谓“寸有所长，尺有所短”就是这个道理。

一般来说，GDB主要帮忙你完成下面四个方面的功能：1、启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。

2、可让被调试的程序在你所指定的调置的断点处停住。

（断点可以是条件表达式）3、当程序被停住时，可以检查此时你的程序中所发生的事。

4、动态的改变你程序的执行环境。

从上面看来，GDB和一般的调试工具没有什么两样，基本上也是完成这些功能，不过在细节上，你会发现GDB这个调试工具的强大，大家可能比较习惯了图形化的调试工具，但有时候，命令行的调试工具却有着图形化工具所不能完成的功能。

让我们一一看来。

一个调试示例——————源程序：tst.c1 #include23 int func(int n)4 {5 int sum=0,i;6 for(i=0; i7 {8 sum+=i;9 }10 return sum;11 }121314 main()15 {16 int i;17 long result = 0;18 for(i=1; i<=100; i++)19 {20 result += i;21 }2223 printf("result[1-100] = %d ", result );24 printf("result[1-250] = %d ", func(250) );25 }编译生成执行文件：（Linux下）hchen/test> cc -g tst.c -o tst使用GDB调试：hchen/test> gdb tst <---------- 启动GDBGNU gdb 5.1.1Copyright 2002 Free Software Foundation, Inc.GDB is free software, covered by the GNU General Public License, and you are welcome to change it and/or distribute copies of it under certain conditions. Type "show copying" to see the conditions.There is absolutely no warranty for GDB. Type "show warranty" for details. This GDB was configured as "i386-suse-linux"...(gdb) l <-------------------- l命令相当于list，从第一行开始例出原码。

实验2 Linux下C语言程序的编译与调试

6. 启动 Gdb 调试：gdb greet。 7. 查看源代码，使用命令“l”。 8. 在 23 行(for 循环处)设置断点，使用命令“b 23”。 9. 在 26 行(printf 函数处)设置断点，使用命令“b 26”。 10.查看断点设置情况，使用命令“info b”。 11.运行代码，使用命令“r”。 12.单步运行代码，使用命令“n” 13.查看暂停点变量值，使用命令“p string2[size - i]”。 14.继续单步运行代码数次，并使用命令查看，发现 string2[size-1]的值正确。 15.继续程序的运行，使用命令“c”。 16.程序在 printf 前停止运行，此时依次查看 string2[0]、string2[1]„，发现
实验 2 Linux 下 C 语言程序的编译与调试
一、实验内盘上输入 4 个整数，找出其中最大的整数的程序，用 gcc/g++ 编译并观察编译后的结果。
2. 用 gdb 调试该程序。 3. 运行生成可执行文件。
二、实验目的：
1. 练习 Vi 编辑器来编译 C 程序。 2. 学会使用 gcc/g++编译、gdb 调试 C 程序。
四、实验分析
为了使 GDB 正常工作，必须使程序在编译时包含调试信息。调试信息里包含程序里的每个变量的类型和在可执行文件里的地址映射以及源代码的行号。GDB 利用这些信息使源代码和机器码相关联。所以在编译时用-g 选项打开调试选项。
GCC 命令的基本用法：gcc [options] [filename] -o 选项为即将产生的可执行文件指定一个文件名来代替默认的 a.out。 GDB 是一个用来调试 C 和 C++程序的强有力的调试器。它使用户能在程序运行时观察程序的内部结构和内存的使用情况。

教你在Linux下用GDB调试程序

教你在Linux下用GDB调试程序一、使用GDB一般来说GDB主要调试的是C/C++的程序。

要调试C/C++的程序，首先在编译时，我们必须要把调试信息加到可执行文件中。

使用编译器（cc/gcc/g++）的-g参数可以做到这一点。

如：$gcc-g-Wall hello.c-o hello$g++-g-Wall hello.cpp-o hello如果没有-g，你将看不见程序的函数名、变量名，所代替的全是运行时的内存地址。

当你用-g把调试信息加入之后，并成功编译目标代码以后，让我们来看看如何用gdb来调试他。

启动GDB的方法有以下几种：•gdb<program>program也就是你的执行文件，一般在当前目录下。

•gdb<program>core用gdb同时调试一个运行程序和core文件，core是程序非法执行后core dump后产生的文件。

•gdb<program><PID>如果你的程序是一个服务程序，那么你可以指定这个服务程序运行时的进程ID。

gdb会自动attach上去，并调试他。

program应该在PATH环境变量中搜索得到。

GDB启动时，可以加上一些GDB的启动开关，详细的开关可以用gdb-help查看。

我在下面只例举一些比较常用的参数：-symbols<file>-s<file>从指定文件中读取符号表。

-se file从指定文件中读取符号表信息，并把他用在可执行文件中。

-core<file>-c<file>调试时core dump的core文件。

-directory<directory>-d<directory>加入一个源文件的搜索路径。

默认搜索路径是环境变量中PATH所定义的路径。

二、GDB的命令概貌启动gdb后，你就被带入gdb的调试环境中，就可以使用gdb的命令开始调试程序了，gdb 的命令可以使用help命令来查看，如下所示：GNU gdb6.7.1-debianCopyright(C)2007Free Software Foundation,Inc.License GPLv3+:GNU GPL version3or later</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)helpList of classes of commands:aliases--Aliases of other commandsbreakpoints--Making program stop at certain pointsdata--Examining datafiles--Specifying and examining filesinternals--Maintenance commandsobscure--Obscure featuresrunning--Running the programstack--Examining the stackstatus--Status inquiriessupport--Support facilitiestracepoints--Tracing of program execution without stopping the programuser-defined--User-defined commandsType"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.(gdb)gdb的命令很多，gdb把之分成许多个种类。

linux下如何用GDB调试c程序

linux下如何用GDB调试c程序GDB 是GNU开源组织发布的一个强大的UNIX下的程序调试工具。

或许，各位比较喜欢那种图形界面方式的，像VC、BCB等IDE的调试，但如果你是在 UNIX平台下做软件，你会发现GDB这个调试工具有比VC、BCB的图形化调试器更强大的功能。

所谓“寸有所长，尺有所短”就是这个道理。

一般来说，GDB主要帮忙你完成下面四个方面的功能：1.启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。

2.可让被调试的程序在你所指定的调置的断点处停住。

（断点可以是条件表达式）3.当程序被停住时，可以检查此时你的程序中所发生的事。

4.动态的改变你程序的执行环境。

让我们一一看来。

gdb基本命令列表：实例:1 新建一个源文件vi 源文件内容如下：#include<iostream> using namespace std; void swap(int &a,int &b) {int tmp;tmp=a;a=b;b=tmp;}int main(){int i,j;cout<<endl<<'Input two int number:'<<endl;cin>>i>>j;cout<<'Before swap(),i='<<i<<' j='<<j<<endl;swap(i,j);cout<<'After swap(),i='<<i<<' j='<<j<<endl<<endl;return 0;}直接复制粘贴生成源文件2.生成可执行文件 g -g -o swap ，注意必须使用-g参数，编译会加入调试信息，否则无法调试执行文件3.启动调试 gdb swap3.1 查看源文件 list 1，回车重复上一次指令3.2设置调试断点 break 16，在第16行设置断点，info break查看断点信息（亦可使用缩写i b ）3.3 调试运行输入run 或者r3.3 单步调试，step 或者 s进入函数内部3.4查看变量 print b 或者 p b3.5查看函数堆栈bt，退出函数finish3.6 继续运行直到下一个断点或主函数结束continue或者c3.7 退出调试输入q。

Linux开发入门：使用gdb调试C_C++入门教程PPT模板

点
c
2-3如何在cpp函
数断点
e
2-5获取所有断点
f
2-6如何启用或禁
用断点
第2章学会设置断点
2-7如何忽略或删除断点
202x
感谢聆听
202x
linux开发入门：使用gdb调试c/c++入门教程
演讲人
2 0 2 x - 11 - 11
目录
01. 第1章gdb基础入门 02. 第2章学会设置断点
01 第1章gdb基础入门
第1章gdb 基础入门
01
1-1如何使用gdb
04
1-4如何查看程序停止哪一行代码
02
1-2如何运行或停止程
序
05
1-ห้องสมุดไป่ตู้如何单步调试
03
1-3程序停下来后、如何继续执行
06
1-6如何查看变量的值
第1章gdb基础入门
1-7如何修改变量的值 1-8调试过程中如何调用函数 1-9如何从函数返回
02 第2章学会设置断点
a
2-1如何在指定行
断点
d
2-4如何设置临时
断点
第2章学会设置断点
b
2-2如何在函数断

Linux命令高级技巧使用gdb命令进行程序调试和分析

Linux命令高级技巧使用gdb命令进行程序调试和分析在Linux环境中，gdb是程序员们常用的工具之一，用于调试和分析程序。

gdb是GNU调试器的缩写，它提供了多种功能和选项，能够帮助程序员追踪程序的执行过程，找出错误并进行修复。

本文将介绍一些使用gdb进行程序调试和分析的高级技巧，希望能对读者有所帮助。

一、gdb简介gdb是一个功能强大的调试工具，它可以在程序执行过程中暂停程序，并允许程序员查看、修改程序状态。

gdb支持多种编程语言，包括C、C++、Fortran等。

使用gdb可以帮助程序员分析程序的执行流程、内存使用情况以及变量状态等，从而帮助定位并解决程序的bug。

二、基本调试技巧1. 启动程序调试使用gdb调试程序时，需要在命令行中输入"gdb 程序名"的命令来启动gdb。

例如，要调试一个名为"test"的程序，可以输入以下命令：```gdb test```2. 设置断点断点是gdb中非常有用的功能，可以在程序中指定位置设置断点，使程序执行到该位置时暂停。

通过暂停程序的执行，可以查看程序中的变量值以及执行流程，有助于定位问题。

设置断点的命令是"break"或"b"，后跟着要设置断点的位置。

例如，要在程序的第10行设置断点，可以输入以下命令：```break 10```3. 执行程序在设置好断点后，可以使用"gdb"命令来开始执行程序。

程序将会运行到第一个断点处暂停。

4. 单步执行单步执行是gdb中常用的调试技巧之一，可以逐行执行程序，方便查看程序的执行过程。

gdb提供了多种单步执行的命令，包括"step"和"next"。

- "step"命令用于逐行执行程序，包括进入函数内部。

如果当前行是函数调用语句，gdb将进入该函数，然后停在函数内部的第一行。

在Windowslinux下进行gdb调试

在Windowslinux下进⾏gdb调试GDB是⼀个由GNU开源组织发布的、UNIX/LINUX操作系统下的、基于命令⾏的、功能强⼤的程序调试⼯具。

对于⼀名Linux下⼯作的c/c++程序员，gdb是必不可少的⼯具；⼆、gdb使⽤流程这⾥⽤c程序做基本演⽰，c++程序也是⼀样的；1、启动gdb编译⼀个测试程序，-g表⽰可以调试，命令如下：gcc -g test.c -o test1启动gdb，命令如下：gdb testgdb -q test //表⽰不打印gdb版本信息，界⾯较为⼲净；测试如下：root@ubuntu:/home/eit/c_test# gdb -q testReading symbols from test...done.(gdb)到此gdb启动完成！2、查看源码list(简写 l)：查看源程序代码，默认显⽰10⾏，按回车键继续看余下的。

测试如下：(gdb) list9 #define MAX_SIZE1011 int main()12 {13 int i,fd,size1 ,size2 ,len;14 char *buf = "helo!I'm liujiangyong ";15 char buf_r[15];16 len = strlen(buf);17 fd = open("/home/hello.txt",O_CREAT | O_TRUNC | O_RDWR,0666);18 if (fd<0)(gdb)19 {20 perror("open :");21 exit(1);22 }23 else24 {25 printf("open file:hello.txt %d\n",fd);26 }27 size1 = write(fd,buf,len);28 if (fd<0)(gdb)29 {30 printf("writre erro;");3132 }33 else34 {35 printf("写⼊的长度：%d\n写⼊⽂本内容：%s\n",size1,buf);3637 }38 lseek(fd,0,SEEK_SET);(gdb)39 size2 = read(fd,buf_r,12);40 if (size2 <0)41 {42 printf("read erro\n");43 }45 {46 printf("读取长度：%d\n ⽂本内容是：%s\n",size2,buf_r);47 }48 close(fd);(gdb)495051 }(gdb)Line number 52 out of range; write.c has 51 lines.(gdb)3、运⾏程序run(简写 r) ：运⾏程序直到遇到结束或者遇到断点等待下⼀个命令；测试如下：(gdb) rThe program being debugged has been started already.Start it from the beginning? (y or n) yStarting program: /home/eit/c_test/testopen file:hello.txt 3写⼊的长度：22写⼊⽂本内容：helo!I'm liujiangyong读取长度：12⽂本内容是：helo!I'm liu[Inferior 1 (process 19987) exited normally](gdb)4、设置断点break(简写 b) ：格式 b ⾏号，在某⾏设置断点；info breakpoints ：显⽰断点信息Num：断点编号Disp：断点执⾏⼀次之后是否有效 kep：有效 dis：⽆效Enb：当前断点是否有效 y：有效 n：⽆效Address：内存地址What：位置(gdb) b 5Breakpoint 3 at 0x400836: file write.c, line 5.(gdb) b 26Breakpoint 4 at 0x4008a6: file write.c, line 26.(gdb) b 30Breakpoint 5 at 0x4008c6: file write.c, line 30.(gdb) info breakpointsNum Type Disp Enb Address What3 breakpoint keep y 0x0000000000400836 in main at write.c:54 breakpoint keep y 0x00000000004008a6 in main at write.c:265 breakpoint keep y 0x00000000004008c6 in main at write.c:30 (gdb)5、单步执⾏使⽤ continue、step、next命令测试如下：(gdb) rStarting program: /home/eit/c_test/testBreakpoint 3, main () at write.c:1212 {(gdb) n14 char *buf = "helo!I'm liujiangyong ";(gdb)16 len = strlen(buf);(gdb)17 fd = open("/home/hello.txt",O_CREAT | O_TRUNC | O_RDWR,0666); (gdb) sopen64 () at ../sysdeps/unix/syscall-template.S:8181 ../sysdeps/unix/syscall-template.S: No such file or directory.main () at write.c:1818 if (fd<0)(gdb)25 printf("open file:hello.txt %d\n",fd);(gdb)__printf (format=0x400a26 "open file:hello.txt %d\n") at printf.c:2828 printf.c: No such file or directory.(gdb) cContinuing.open file:hello.txt 3Breakpoint 4, main () at write.c:2727 size1 = write(fd,buf,len);(gdb)Continuing.写⼊的长度：22写⼊⽂本内容：helo!I'm liujiangyong读取长度：12⽂本内容是：helo!I'm liu[Inferior 1 (process 20737) exited normally](gdb)6、查看变量使⽤print、whatis命令测试如下：main () at write.c:2828 if (fd<0)(gdb)35 printf("写⼊的长度：%d\n写⼊⽂本内容：%s\n",size1,buf);(gdb) print fd$10 = 3(gdb) whatis fdtype = int(gdb)7、退出gdb⽤quit命令退出gdb：(gdb) rStarting program: /home/eit/c_test/testopen file:hello.txt 3写⼊的长度：22写⼊⽂本内容：helo!I'm liujiangyong读取长度：12⽂本内容是：helo!I'm liu[Inferior 1 (process 20815) exited normally](gdb) qroot@ubuntu:/home/eit/c_test#continue（简写 c)：继续执⾏程序，直到下⼀个断点或者结束；next（简写 n ）：单步执⾏程序，但是遇到函数时会直接跳过函数，不进⼊函数；step(简写 s) ：单步执⾏程序，但是遇到函数会进⼊函数；until：当你厌倦了在⼀个循环体内单步跟踪时，这个命令可以运⾏程序直到退出循环体；until+⾏号：运⾏⾄某⾏，不仅仅⽤来跳出循环；finish：运⾏程序，直到当前函数完成返回，并打印函数返回时的堆栈地址和返回值及参数值等信息；call 函数(参数)：调⽤程序中可见的函数，并传递“参数”，如：call gdb_test(55)；quit：简记为 q ，退出gdb；三、gdb基本使⽤命令1、运⾏命令run：简记为 r ，其作⽤是运⾏程序，当遇到断点后，程序会在断点处停⽌运⾏，等待⽤户输⼊下⼀步的命令。