文章内容转载自开源项目jaywcjlove/reference（MIT © Kenny Wong）

最近常用到 GDB，一些命令总是需要查一下，找到了这个开源项目，常用的命令和工具总结的比较全面。

本清单提供了对 GDB 的入门简要概述，以及 GDB 常用示例，完整文档参阅 Debugging with gdb，该文档最后有 GDB index，可以快速查找命令。

常用命令

[] 内为命令缩写

启动调试

启动进程，不带参数

1
2

# gdb <program>
(gdb) run

启动进程，带参数 <args>

1
2

# gdb <program>
(gdb) run <args>

启动 gdb 时传入参数，run 就不用传入了

1
2

# gdb --args <program> 1 2 3
(gdb) run

通过 set 设置参数

1
2
3

# gdb <program>
(gdb) set args 1 2 3
(gdb) run

显示运行时将要或已经传递给程序的参数

1

(gdb) show args

在启动进程前，添加环境变量

1

(gdb) set env DEBUG 1

在启动进程前，清除环境变量

1

(gdb) unset env DEBUG

通过进程号 123 连接到正在运行的进程

1

(gdb) attach 123

core dump 文件

默认情况下，linux 系统中程序崩溃时也不会生成 core dump 文件，需要先启用

1
2

ulimit -c unlimited
echo "/tmp/core-%e-%p-%t" > /proc/sys/kernel/core_pattern

调试 core 文件

1

gdb program /tmp/core-file

查看源码

流程控制

断点命令

watch 命令

查看变量

frame 栈帧

每当一个函数被调用时，一个新的栈帧 frame 就会被压入栈中，栈帧包含了该函数的局部变量、参数、返回地址和其他信息，当函数执行完毕后，这个栈帧会被弹出栈并销毁。

函数调用

call 和 print 调用的函数如果存在全局变量、静态变量的修改，在函数返回后会恢复到调用之前的值，这两个调用不会影响程序的状态

信号

linux 下使用 kill -l 查看信号编号与信号名，使用 info signal 查看信号的处理方式、描述等：

1
2
3
4
5
6
7

(gdb) info signal
Signal        Stop  Print   Pass to program Description

SIGHUP        Yes   Yes     Yes             Hangup
SIGINT        Yes   Yes     No              Interrupt
SIGQUIT       Yes   Yes     Yes             Quit
SIGILL        Yes   Yes     Yes             Illegal instruction

线程

使用 Python 的列表做二维数组时，初始化应当使用列表推导式或者使用嵌套循环逐行逐个元素添加，不应当使用*运算创建多行列表，使用list * n形式创建的多个行列表的id是相同的，也就是说这些行引用的是内存中的相同地址，修改任何一行的值，其他行都会被修改。

验证代码

使用一个简短的程序对这个问题进行验证，分别使用了列表推导式、*与列表推导式结合、完全使用*三种方式对二维数组初始化。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

def print_array(array):
    [print(*row) for row in array]

def init1(rows, cols):
    array = [[0 for _ in range(cols)] for _ in range(rows)]
    return array

def init2(rows, cols):
    array = [[0] * cols for _ in range(rows)]
    return array

def init3(rows, cols):
    array = [[0] * cols] * rows
    return array

if __name__ == "__main__":
    rows = 3  # 行数
    cols = 5  # 列数

    array1 = init1(rows, cols)
    print("\narray1:")
    print_array(array1)
    print(f"row0 id:{id(array1[0])}, row1 id:{id(array1[1])}")
    print(f"row0 id == row1 id ?  {id(array1[0])==id(array1[1])}")

    array2 = init2(rows, cols)
    print("\narray2:")
    print_array(array2)
    print(f"row0 id:{id(array2[0])}, row1 id:{id(array2[1])}")
    print(f"row0 id == row1 id ?  {id(array2[0])==id(array2[1])}")

    array3 = init3(rows, cols)
    print("\narray3:")
    print_array(array3)
    print(f"row0 id:{id(array3[0])}, row1 id:{id(array3[1])}")
    print(f"row0 id == row1 id ?  {id(array3[0])==id(array3[1])}")

程序运行的结果如下

程序运行结果

可以看到在创建行时不能简单地使用*创建多行，这样创建的行的内存地址相同。

这个问题的来源

最近用 Python 做到了 LeetCode 中的一道动规题62.不同路径

思路

按描述，走到某一位置的路径可能有两个来源，一个是当前位置左侧的位置，另一个是当前位置的上侧位置，符合基本的动规思路

• 动规数组：dp[i][j]表示从起点到坐标 i,j 处的路径数
• 递推关系：dp[i][j] = dp[i-1][j] + dp[i][j-1]，含义是当前位置的路径数是所有可能的上一步的路径数的加和，可能的上一步即当前位置[i][j]的左侧[i-1][j]或者上侧[i][j-1]
• 初始化：根据递推关系含义，应当对起始的左侧和上侧进行初始化，也就是对地图的左边界，上边界初始化，每个格子的路径都是 1，因为不可能再有其他方案走到这些位置
• 遍历顺序：i,j需要两层循环，两层循环都需要顺序遍历，因为递推关系中使用的是当前位置之前的状态值。两层循环的先后顺序可以任意安排，可以从左到右从上到下 (先j后i，i在j之外)，也可以从上到下从左到右 (先i后j，j在i之外)，因为这不影响dp[i][j]总是在dp[i-1][j]和dp[i][j-1]之后计算这一基本要求

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14

def uniquePaths(self, m: int, n: int) -> int:
    # m 行 n 列
    dp = [[0] * n] * m
    for i in range(m):
        dp[i][0] = 1
    for j in range(n):
        dp[0][j] = 1
    for i in range(1, m):
        for j in range(1, n):
            dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
    # for j in range(1, n):
    #     for i in range(1, m):
    #         dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
    return dp[i][j]

当我尝试用注释掉的两层循环来代替程序中先j后i的循环来说明两层循环的次序并不影响结果时，意外的出现了错误。经过调试发现，在经过对边界值进行初始化的两个循环 (for i in range(m)和for j in range(n)) 后，二维数组中出现了错误，此时数组中的所有值全都变成了 1，只不过程序中先j后i的循环，会一次性使用完一整行的元素之后去遍历下一行，恰好避开了这个错误。但是交换循环次序后，逐列遍历会反复在不同行之间修改元素的值，这会导致其他行也被修改，取到错误的数值，得到错误结果。

将创建dp数组的代码修改后两种循环次序均能够得到正确的结果。