GDB 的简单使用

已于 2023-05-22 22:41:16 修改
阅读量694 收藏
点赞数
分类专栏： C/C++ Linux 文章标签： ubuntu linux 运维 GDB
于 2023-05-13 10:20:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43686863/article/details/130643834
版权
C/C++ 同时被 2 个专栏收录
41 篇文章 6 订阅
订阅专栏
Linux
22 篇文章 0 订阅
订阅专栏

GDB 的简单使用

一、启动调试

直接使用gcc或g++命令编译生成的可执行文件无法直接用于调试，因为它们缺少必要的调试信息（代码行号、符号表等）。因此需要使用 -g 选项编译源文件，生成满足GDB要求的可调试的可执行文件，然后通过 gdb 可执行文件名 启动调试。

atreus@iZwz9fsfltolu74amg1v0rZ:~/Code$ g++ -g remove.cpp -o remove
atreus@iZwz9fsfltolu74amg1v0rZ:~/Code$ gdb remove
GNU gdb (Ubuntu 9.2-0ubuntu1~20.04.1) 9.2
Copyright (C) 2020 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 "x86_64-linux-gnu".
Type "show configuration" for configuration details.
For bug reporting instructions, please see:
<http://www.gnu.org/software/gdb/bugs/>.
Find the GDB manual and other documentation resources online at:
    <http://www.gnu.org/software/gdb/documentation/>.

For help, type "help".
Type "apropos word" to search for commands related to "word"...
Reading symbols from remove...
(gdb) quit
atreus@iZwz9fsfltolu74amg1v0rZ:~/Code$

二、常用调试命令

1.list（显示程序源代码）

list 命令（可以用 l 代替）用于显示程序源代码，默认只显示十行，此默认行数值可以通过 show listsize 查看，并通过 set listsize 一次显示的行数 修改。list 的主要用法如下：

  • list：显示当前行后面的代码，默认从头开始打印。
  • list -：显示当前行前面的代码。
  • list 文件名:行号：打印指定文件中指定行号附近的代码。
  • list 文件名:函数名：打印指定文件中指定函数起始处附近的代码。
  • list 文件名:起始位置,结束位置：打印从起始位置到结束位置的代码。

需要注意的是，文件名参数可以省略，且省略时GDB会按照函数名自动查找或优先处理当前文件。此外在存在函数重载或函数重写时函数名并不唯一，此时可以指定函数的参数类型或函数所属的类类型以区分不同函数，这两点也适用于其他GDB命令。

(gdb) show listsize # 查看默认显示行数
Number of source lines gdb will list by default is 10.
(gdb) list main # 查看main函数附近的代码
1       #include "remove.h"
2
3       using namespace std;
4
5       int main() {
6           Solution solution;
7           vector<int> nums = {0, 1, 2, 2, 3, 0, 4, 2};
8
9           solution.removeElement(nums, 2);
10          for (auto num : nums) {
(gdb) list remove.h:6,23 # 查看remove.h文件中从第6行到第23行的代码
6       class Solution {
7       public:
8           /**
9            * 删除nums中值为val的元素并调整nums的大小
10           */
11          void removeElement(vector<int> &nums, int val) {
12              int slow = 0, fast = 0;
13
14              while (fast < nums.size()) {
15                  if (nums.at(fast) != val) {
16                      nums.at(slow++) = nums.at(fast);
17                  }
18                  fast++;
19              }
20
21              nums.resize(slow); // 根据慢指针位置调整大小
22          }
23      };
(gdb) list removeElement(std::vector<int, std::allocator<int>> &, int) # 指定函数的参数类型，可以解决函数重载
6       class Solution {
7       public:
8           /**
9            * 删除nums中值为val的元素并调整nums的大小
10           */
11          void removeElement(vector<int> &nums, int val) {
12              int slow = 0, fast = 0;
13
14              while (fast < nums.size()) {
15                  if (nums.at(fast) != val) {
(gdb) list Solution::removeElement # 指定函数的所属类，可以解决函数重写
6       class Solution {
7       public:
8           /**
9            * 删除nums中值为val的元素并调整nums的大小
10           */
11          void removeElement(vector<int> &nums, int val) {
12              int slow = 0, fast = 0;
13
14              while (fast < nums.size()) {
15                  if (nums.at(fast) != val) {
(gdb) list - # 向前查看代码
1       #include <iostream>
2       #include <vector>
3
4       using namespace std;
5
(gdb)

2.break、tbreak、delete、disable、enable 和 info break（断点操作）

break 命令（可以用 b 代替）用于设置断点，它的主要用法如下：

  • break 文件名:行号：在指定文件的指定行号设置断点。
  • break 文件名:函数名：在指定文件的指定函数起始处设置断点。

此外还可以通过 break 断点位置 if 条件 命令设置条件断点，当指定条件满足时程序会被中断到指定位置。

tbreak 也用于设置断点，只不过它设置的断点为临时断点，所谓临时断点，就是指该断点触发一次后就会自动删除。

delete 命令（可以用 d 代替）用于删除断点，主要用法如下：

  • delete 断点编号：删除一个或多个指定编号的断点，指定多个时以空格分隔即可。
  • delete：不指定断点编号则会删除所有断点。

断点不但可以删除，也可以被禁用，所谓禁用就是使目标断点暂时失去作用，必要时可以再将其激活，恢复断点原有的功能。断点通过 disable 命令禁用，禁用后通过 enable 激活，二者用法与 delete 类似。

info break 命令用于查看当前程序中的断点信息。

(gdb) break remove.h:14 # 在remove.h的第14行处添加断点
Breakpoint 1 at 0x1558: file remove.h, line 14.
(gdb) break removeElement # 在removeElement函数起始处添加断点
Breakpoint 2 at 0x1532: file remove.h, line 11.
(gdb) break main # 在main函数起始处添加断点
Breakpoint 3 at 0x1309: file remove.cpp, line 5.
(gdb) info break # 查看当前所有的断点信息
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000001558 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:14
2       breakpoint     keep y   0x0000000000001532 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:11
3       breakpoint     keep y   0x0000000000001309 in main() at remove.cpp:5
(gdb) delete 3 # 删除编号为3的断点
(gdb) info break # 查看当前所有的断点信息
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000001558 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:14
2       breakpoint     keep y   0x0000000000001532 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:11
(gdb) tbreak main # 在main函数起始处添加临时断点
Temporary breakpoint 4 at 0x1309: file remove.cpp, line 5.
(gdb) info break # 查看当前所有的断点信息
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000001558 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:14
2       breakpoint     keep y   0x0000000000001532 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:11
4       breakpoint     del  y   0x0000000000001309 in main() at remove.cpp:5
(gdb) disable 4 # 禁用编号为4的断点
(gdb) info break # 查看当前所有的断点信息
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000001558 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:14
2       breakpoint     keep y   0x0000000000001532 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:11
4       breakpoint     del  n   0x0000000000001309 in main() at remove.cpp:5
(gdb) 

(gdb) break remove.h:15 if fast = 3 # 当fast等于3时在remove.h第15行处中断
Breakpoint 1 at 0x1574: file remove.h, line 15.
(gdb) info break
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000001574 in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:15
        stop only if fast = 3
(gdb) run
Starting program: /home/atreus/Code/gdb_demo/remove 

Breakpoint 1, Solution::removeElement (this=0x7fffffffe163, nums=std::vector of length 8, capacity 8 = {...}, val=2) at remove.h:15
warning: Source file is more recent than executable.
15                  if (nums.at(fast) != val) {
(gdb) display fast
1: fast = 3
(gdb)

3.run 和 continue（运行源程序）

run 命令（可以用 r 代替）用于启动源程序，默认会运行到第一个断点处，如果没有设置断点，会直接执行完可执行程序。

continue （可以用 c 代替）会在程序被中断后重新恢复程序的执行，直到触发断点或程序结束。

(gdb) tbreak main
Temporary breakpoint 1 at 0x1309: file remove.cpp, line 5.
(gdb) tbreak remove.h:removeElement
Temporary breakpoint 2 at 0x1532: file remove.h, line 11.
(gdb) run # 启动源程序
Starting program: /home/atreus/Code/gdb_demo/remove 

Temporary breakpoint 1, main () at remove.cpp:5
5       int main() {
(gdb) continue # 恢复源程序执行
Continuing.

Temporary breakpoint 2, Solution::removeElement (this=0x7fffffffe170, nums=std::vector of length -35184372086969, capacity -11728124003598 = {...}, val=0) at remove.h:11
warning: Source file is more recent than executable.
11          void removeElement(vector<int> &nums, int val) {
(gdb) # 继续执行
Continuing.
0
1
3
0
4
[Inferior 1 (process 398883) exited normally]
(gdb)

4.next 和 step（单步调试）

next 命令（可以用 n 代替）表示单步步过（stepping over）。

step 命令（可以用 s 代替）表示单步步入（stepping into），它会在遇到函数调用时进入到函数内部去执行。

(gdb) break main
Breakpoint 1 at 0x1309: file remove.cpp, line 5.
(gdb) list remove.cpp:1,15
1       #include "remove.h"
2
3       using namespace std;
4
5       int main() {
6           Solution solution;
7           vector<int> nums = {0, 1, 2, 2, 3, 0, 4, 2};
8
9           solution.removeElement(nums, 2);
10          for (auto num : nums) {
11              cout << num << endl;
12          }
13
14          return 0;
15      }
(gdb) run
Starting program: /home/atreus/Code/remove 

Breakpoint 1, main () at remove.cpp:5
5       int main() {
(gdb) next # 单步步过
7           vector<int> nums = {0, 1, 2, 2, 3, 0, 4, 2};
(gdb) 
9           solution.removeElement(nums, 2);
(gdb) step # 单步步入
Solution::removeElement (this=0x7fffffffe190, nums=std::vector of length -35184372086977, capacity -11728124003606 = {...}, val=0) at remove.h:11
11          void removeElement(vector<int> &nums, int val) {
(gdb)

5.finish 和 return（函数返回）

finish 和 return 均用于从当前函数中返回，二者主要区别如下：

  • finish 表示执行完当前函数并返回到函数调用处，即会一直执行到函数正常再退出。
  • return 表示直接结束当前函数执行并返回到函数调用处，还可以指定函数返回值，这也就意味着即使当前函数还有剩余代码，但也不会执行了。
(gdb) list 1,13
1       #include <stdio.h>
2
3       int func() {
4           int ret = 0;
5
6           return ret;
7       }
8
9       int main() {
10          printf("%d\n", func());
11
12          return 0;
13      }
(gdb) break 3
Breakpoint 1 at 0x1149: file main.c, line 3.
(gdb) run
Starting program: /home/atreus/Code/main 

Breakpoint 1, func () at main.c:3
3       int func() {
(gdb) next
4           int ret = 0;
(gdb) return -1 # 以-1返回值直接返回
Make func return now? (y or n) y
#0  0x000055555555516f in main () at main.c:10
10          printf("%d\n", func());
(gdb) next
-1
12          return 0;
(gdb) 

(gdb) run
Starting program: /home/atreus/Code/main 

Breakpoint 1, func () at main.c:3
3       int func() {
(gdb) next
4           int ret = 0;
(gdb) finish # 继续执行完当前函数
Run till exit from #0  func () at main.c:4
0x000055555555516f in main () at main.c:10
10          printf("%d\n", func());
Value returned is $1 = 0
(gdb) next
0
12          return 0;
(gdb)

6.print、display 和 ptype（查看变量信息）

print（可以用 p 代替）用于在调试过程中查看变量的值或内存地址，ptype 命令用于输出变量的类型。

display 也可以查看监视的变量或者内存地址，而且会在每次程序中断下来时进行输出，通过 delete display 清除需要自动输出的变量。

(gdb) break remove.h:14
Breakpoint 1 at 0x1558: file remove.h, line 14.
(gdb) run
Starting program: /home/atreus/Code/remove 

Breakpoint 1, Solution::removeElement (this=0x7fffffffe183, nums=std::vector of length 8, capacity 8 = {...}, val=2) at remove.h:14
14              while (fast < nums.size()) {
(gdb) print this # 打印this指针的值
$1 = (Solution * const) 0x7fffffffe183
(gdb) print fast # 打印fast变量的值
$2 = 0
(gdb) print &fast # 打印fast变量的地址
$3 = (int *) 0x7fffffffe15c
(gdb) print nums.at(fast) # 打印指定表达式的值
$4 = 0
(gdb) print nums.at(fast) == 0
$5 = true
(gdb) display slow # 在每次中断时输出fast的值
1: slow = 0
(gdb) display fast
2: fast = 0
(gdb) next
15                  if (nums.at(fast) != val) {
1: slow = 0
2: fast = 0
(gdb) 
16                      nums.at(slow++) = nums.at(fast);
1: slow = 0
2: fast = 0
(gdb) 
18                  fast++;
1: slow = 1
2: fast = 0
(gdb) delete display 1
(gdb) next
14              while (fast < nums.size()) {
2: fast = 1
(gdb) ptype fast # 打印fast变量的类型
type = int
(gdb) ptype nums # 打印nums的类型，它是一个vevtor容器
type = class std::vector<int> [with _Tp = int, _Alloc = std::allocator<int>] : protected std::_Vector_base<_Tp, _Alloc> {
  private:
    static bool _S_nothrow_relocate(std::true_type);
    static bool _S_nothrow_relocate(std::false_type);
    static bool _S_use_relocate(void);
    static pointer _S_do_relocate(pointer, pointer, pointer, _Alloc &, std::true_type);
    static pointer _S_do_relocate(pointer, pointer, pointer, _Alloc &, std::false_type);
    static pointer _S_relocate(pointer, pointer, pointer, _Alloc &);
  public:
    vector(void);
    vector(const _Alloc &);
    vector(size_type, const _Alloc &);
    vector(size_type, reference, const _Alloc &);
    vector(const std::vector<int> &);
    vector(std::vector<int> &&);
    vector(const std::vector<int> &, const _Alloc &);
  private:
    vector(std::vector<int> &&, const _Alloc &, std::true_type);
    vector(std::vector<int> &&, const _Alloc &, std::false_type);
  public:
    vector(std::vector<int> &&, const _Alloc &);
    vector(std::initializer_list<_Tp>, const _Alloc &);
    ~vector();
    std::vector<int> & operator=(const std::vector<int> &);
    std::vector<int> & operator=(std::vector<int> &&);
    std::vector<int> & operator=(std::initializer_list<_Tp>);
    void assign(size_type, reference);
    void assign(std::initializer_list<_Tp>);
    iterator begin(void);
    const_iterator begin(void) const;
    iterator end(void);
    const_iterator end(void) const;
    reverse_iterator rbegin(void);
    const_reverse_iterator rbegin(void) const;
    reverse_iterator rend(void);
    const_reverse_iterator rend(void) const;
    const_iterator cbegin(void) const;
    const_iterator cend(void) const;
    const_reverse_iterator crbegin(void) const;
    const_reverse_iterator crend(void) const;
    size_type size(void) const;
    size_type max_size(void) const;
    void resize(size_type);
    void resize(size_type, reference);
    void shrink_to_fit(void);
    size_type capacity(void) const;
    bool empty(void) const;
    void reserve(size_type);
    reference operator[](size_type);
    reference operator[](size_type) const;
--Type <RET> for more, q to quit, c to continue without paging--q
Quit
(gdb) ptype nums.resize()
type = void
(gdb)

7.watch（添加数据断点）

watch 用于监视一个变量或者一段内存，当这个变量或该内存处的值发生变化时，gdb就会中断下来，通过 watch 添加的断点一般被称为数据断点，有时候也被称为硬件断点。

但是与 break 添加的普通断点不同的是，数据断点必须在程序运行时设置，在执行 run 命令之前对变量设置数据断点会提示无法在当前上下文中找到对应符号。

(gdb) break remove.h:12
Breakpoint 1 at 0x154a: file remove.h, line 12.
(gdb) run
Starting program: /home/atreus/Code/gdb_demo/remove 

Breakpoint 1, Solution::removeElement (this=0x7fffffffe163, nums=std::vector of length 8, capacity 8 = {...}, val=2) at remove.h:12
12              int slow = 0, fast = 0;
(gdb) watch slow # 为slow变量添加一个数据断点，每当它的值发生变化时将程序中断下来
Hardware watchpoint 2: slow
(gdb) info break
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x000055555555554a in Solution::removeElement(std::vector<int, std::allocator<int> >&, int) at remove.h:12
        breakpoint already hit 1 time
2       hw watchpoint  keep y                      slow
(gdb) continue
Continuing.

Hardware watchpoint 2: slow

Old value = 1431656218
New value = 0
Solution::removeElement (this=0x7fffffffe163, nums=std::vector of length 8, capacity 8 = {...}, val=2) at remove.h:12
12              int slow = 0, fast = 0;
(gdb) 
Continuing.

Hardware watchpoint 2: slow

Old value = 0
New value = 1
Solution::removeElement (this=0x7fffffffe163, nums=std::vector of length 8, capacity 8 = {...}, val=2) at remove.h:16
16                      nums.at(slow++) = nums.at(fast);
(gdb)

8.backtrace 和 frame（函数调用栈）

backtrace（可以用 bt 代替）命令用于查看当前线程的函数调用栈。

frame 用于切换当前栈帧，info frame 用于打印当前栈帧信息。

(gdb) break 3
Breakpoint 1 at 0x114d: file recursion.cpp, line 3.
(gdb) run
Starting program: /home/atreus/Code/gdb_demo/recursion 

Breakpoint 1, func (x=10) at recursion.cpp:3
3               return;
(gdb) backtrace # 查看当前的函数调用栈
#0  func (x=10) at recursion.cpp:3
#1  0x000055555555514b in func (x=9) at recursion.cpp:5
#2  0x000055555555514b in func (x=8) at recursion.cpp:5
#3  0x000055555555514b in func (x=7) at recursion.cpp:5
#4  0x000055555555514b in func (x=6) at recursion.cpp:5
#5  0x000055555555514b in func (x=5) at recursion.cpp:5
#6  0x000055555555514b in func (x=4) at recursion.cpp:5
#7  0x000055555555514b in func (x=3) at recursion.cpp:5
#8  0x000055555555514b in func (x=2) at recursion.cpp:5
#9  0x000055555555514b in func (x=1) at recursion.cpp:5
#10 0x000055555555514b in func (x=0) at recursion.cpp:5
#11 0x0000555555555162 in main () at recursion.cpp:10
(gdb) backtrace 3 # 查看当前的函数调用栈栈顶的三个栈帧
#0  func (x=10) at recursion.cpp:3
#1  0x000055555555514b in func (x=9) at recursion.cpp:5
#2  0x000055555555514b in func (x=8) at recursion.cpp:5
(More stack frames follow...)
(gdb) backtrace -3 # 查看当前的函数调用栈栈底的三个栈帧
#9  0x000055555555514b in func (x=1) at recursion.cpp:5
#10 0x000055555555514b in func (x=0) at recursion.cpp:5
#11 0x0000555555555162 in main () at recursion.cpp:10
(gdb) frame 5 # 切换到5号栈帧
#5  0x000055555555514b in func (x=5) at recursion.cpp:5
5               func(x + 1);
(gdb) info frame # 打印当前栈帧信息
Stack level 5, frame at 0x7fffffffe140:
 rip = 0x55555555514b in func (recursion.cpp:5); saved rip = 0x55555555514b
 called by frame at 0x7fffffffe160, caller of frame at 0x7fffffffe120
 source language c++.
 Arglist at 0x7fffffffe118, args: x=5
 Locals at 0x7fffffffe118, Previous frame's sp is 0x7fffffffe140
 Saved registers:
  rbp at 0x7fffffffe130, rip at 0x7fffffffe138
(gdb)

附、调试代码

remove.h：

#include <iostream>
#include <vector>

using namespace std;

class Solution {
public:
    /**
     * 删除nums中值为val的元素并调整nums的大小
     */
    void removeElement(vector<int> &nums, int val) {
        int slow = 0, fast = 0;

        while (fast < nums.size()) {
            if (nums.at(fast) != val) {
                nums.at(slow++) = nums.at(fast);
            }
            fast++;
        }

        nums.resize(slow); // 根据慢指针位置调整大小
    }
};

remove.cpp：

#include "remove.h"

using namespace std;

int main() {
    Solution solution;
    vector<int> nums = {0, 1, 2, 2, 3, 0, 4, 2};

    solution.removeElement(nums, 2);
    for (auto num : nums) {
        cout << num << endl;
    }

    return 0;
}

recursion.cpp

void func(int x) {
    if (x == 10) {
        return;
    } else {
        func(x + 1);
    }
}

int main() {
    func(0);
    return 0;
}

在这里插入图片描述

呦，又写BUG呢
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
gdb watch
Blaider的专栏
05-17 2707
gdb watch 跟踪变量的变化 01 #include 02 #include 03 #include 04 05 int main() 06 { 07     char * name = NULL; 08     int len = 10; 09 10     name = (char *)malloc(len); 11     strncpy(name,
Linux下gdb调试-设置观察点说明一
wojiaxiaohuang2014的博客
10-26 1546
Linux下gdb调试-设置观察点的方法
gdb基本命令
OpenSourceNetCoder
03-27 437
为了记忆，就打上来与大家分析，常用的gdb调试命令：bt 查看各级函数调用及参数finish 连续运行到当前函数返回为止，然后停下来等待命令f 选择栈帧i 查看当前栈帧局部变量的值l 列出源代码list 行号 列出从第几行开始的源代码list 函数名 列出某个函数的源代码n 执行下一条语句p 打印表达式的值set va
GDB调试
qq_36553387的博客
03-07 257
GDB调试 运行命令 run：运行程序，当遇到断点后，程序会在断点处停止运行，等待用户输入下一步的命令； continue：继续执行，到下一个断点处（或运行结束）； next：单步跟踪程序，当遇到函数调用时，也不进入函数体；此命令同step的主要区别是，step遇到用户自定义的函数，将进入到函数中运行，而next则直接电泳函数，不会进入到函数体内； step：单步调试如果有函数调用，则进入函数；与命令next不同，next不进入调用的函数； until：可以运行程序直到退出循环体； until + 行号：
gdb调试常用指令及案例讲解
最新发布
明天你好的博客
04-19 7595
GDB是一个由GNU开源组织发布的、UNIX/LINUX 操作系统下的、基于命令行的、功能强大的程序调试工具。GDB 支持断点、单步执行、打印变量、观察变量、查看寄存器、查看堆栈等调试手段。在 Linux 环境软件开发中，GDB 是主要的调试工具，用来调试 C 和 C++ 程序（也支持 go 等其他语言）。
GDB调试之watch变量跟踪
↓
04-29 1万+
开发中经常遇到某个变量明明已经赋值了，但是最后得到的结果却并非赋予的值。解决这样问题让人很头疼，原因我们可能都知道，可能是内存越界导致这部分值被覆盖掉了，但是什么时候被覆盖掉的呢？总不能在每个怀疑的地方打印这个值吧？这样效率很低，而且定位不一定准确。这个时候使用gdb调试中的watch就可以轻松搞定。 顾名思义跟linux中的watch命令类似：实时的监视你需要查看的内容。比如下面程序： #...
gdb 软件调试使用手册
02-13
手册首先以一个简单的gdb调试会话为例，展示了如何启动和退出gdb。要启动gdb，有多种方式，包括指定要调试的程序、源代码文件、可执行文件等。gdb提供了多种模式，以适应不同的调试需求。在启动过程中，gdb会执行一...
Linux调试工具GDB使用简易教程
01-20
本文所述主要是Linux调试工具GDB的使用教程，具体如下。 声明：本博客内容是由本人经过实验楼教程整理得来。 GDB的相关概念 GDB, 是 The GNU Project Debugger 的缩写, 是 Linux 下功能全面的调试工具。GDB 支持断点...
如何使用GDB调试PHP程序
10-23
要使用GDB调试这个程序，首先需要编译并添加调试信息： ```bash g++ k.cpp -g -Wall -Werror -o main ``` 然后启动GDB并加载程序： ```bash gdb ./main ``` 在GDB中，你可以执行以下操作： - **列出源代码**：`...
GDB调试简易教程.
04-21
linux环境下，代码调试，多线程调试，常用调试方式快速定位问题
[ Linux ] Linux调试器--gdb使用
CSDN博客
09-06 1975
gdb的使用
使用GDB中的watch来调试指来指去的指针
↓
08-15 2317
引言 C代码中经常会有大量的指针在很多不同函数中传来传去，甚至还有强制类型转换，让阅读代码和调试BUG的人苦不堪言。更有甚者将全局变量指针赋值给局部变量，然后再作为参数传出并修改。 这是官网的说明：http://sourceware.org/gdb/current/onlinedocs/gdb/Set-Watchpoints.html#Set-Watchpoints 说明 watch是gdb众多命令中的一个，用来检测变量，当被监测的变量被修改时，...
【C/C++ 调试 GDB指南 】gdb调试基本操作
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
07-01 3128
GDB 全称“GNU symbolic debugger”，从名称上不难看出，它诞生于 GNU 计划（同时诞生的还有 GCC、Emacs 等），是 Linux 下常用的程序调试器。发展至今，GDB 已经迭代了诸多个版本，当下的 GDB 支持调试多种编程语言编写的程序，包括 C、C++、Go、Objective-C、OpenCL、Ada 等。实际场景中，GDB 更常用来调试 C 和 C++ 程序。
C++ gdb调试
红尘道，红尘练心
05-11 4397
基础用法 1. 简介 GDB（GNU Debugger）是GCC的调试工具。其功能强大，现描述如下： GDB主要帮忙你完成下面四个方面的功能： 1.启动你的程序，可以按照你的自定义的要求随心所欲的运行程序。 2.可让被调试的程序在你所指定的调置的断点处停住。（断点可以是条件表达式） 3.当程序被停住时，可以检查此时你的程序中所发生的事。 4.动态的改变你程序的执行环境。 2 生成调试信息 一般来说GDB主要调试的是C/C++的程序。要调试C/C++的程序，首先在编译时，我们必须要把调试信息...
gdb调试跟踪代码
qq_43287931的博客
12-28 900
gdb调试跟踪函数
GDB——使用GDB实时监控变量
热门推荐
食梦者
06-13 1万+
示例代码： #include &lt;stdio.h&gt; #include &lt;pthread.h&gt; #include &lt;unistd.h&gt; int g_var = 0; void* thread_func(void* args) { sleep(5); g_var = 1; } int main() { int i = 0; p...
GDB调试方法：查看变量
weixin_34392435的博客
01-23 964
基本的命令 p 使用这个命令，还可以查看结构体的各元素值。 例：p *pstData; 复杂的命令 使用 dislpaly 命令，自动显示变量的值。 使用 command 命令，执行更复杂的操作，可以执行条件判断。 使用 call 命令，调用打印输出函数。 查看数组变量 p ArrayVar@ItemNum 格式控制 p /x Val /c /f 查看内存变量 x ...
有关gdb调试watch
jfkidear的专栏
08-31 9084
原文件编译的时候要加-g,例gcc -g -o test test.c, 这样在能在调试的时候用list，watch等命令。 全局变量或当前堆栈区可见的变量才能watch，watch之后用Continuing，就可显示观察变量。 gdb watch 跟踪变量的
使用GDB调试C语言程序指南
GDB的启动与退出非常简单。在命令行中输入`gdb`即可启动GDB，其提示符显示为`(gdb)`。若要在启动时直接加载待调试的程序，可以使用`gdb myprog`命令。退出GDB，只需在提示符后输入`quit`或简写`q`。 要使GDB能正确...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值