Linux环境基础开发工具使用

---

前言

在介绍完有关Linux的相关指令和权限之后，我们进一步去学习有关Linux开发工具的使用，这有助于我们随后进一步深入了解Linux，废话不多说了，直接上干货。

1.Linux软件管理器 yum

1.1什么是yum？

yum是一个软件下载安装管理的一个客户端，类似于小米或者华为应用商城之类的

但是在这些类似于yum的软件包是从哪来的？

这就要讲讲Linux系统的生态
Linux上安装软件一般有三种方式：
1.源代码安装 —下载程序的源代码，并进行编译，得到可执行程序
2.rpm包安装—但是第一种太麻烦了，每次都需要重新编译，所以就可以把一些常用的软件提前编译成软件包放在一个服务器上，通过包管理器可以很方便的获取编译好的软件包，直接进行安装
3.yum安装—在rpm包安装的基础上，会再安装软件所需要的库以及所依赖的其他软件

同时，yum是一个Linux下非常常用的一个包管理器，主要应用于Fedora，RedHat，Centos
软件包和包管理器就好比APP和应用商城这样的关系

在上述rpm包安装中，我们要安装所需要的软件的话，我们要到哪个服务器上安装？
我们的机器内部，一定是内置了目标服务器的地址链接，所以能够到对应的服务器上安装我们所需要的软件

1.2关于rzsz

这个工具用于windows机器和远端的Linux机器通过xshell传输文件
安装：yum install -y lrzsz
安装完毕后可以通过拖拽的方式将文件上传

rz将windows上的文件拷贝到Linux上
sz文件名 将Linux上的文件拷贝到windows上

注意事项：
关于yum的所有操作必须保证主机(虚拟机)网络畅通
可以通过ping指令验证

ping www.baidu.com

1.3查看软件包

通过yum list命令可以罗列出当前一共有哪些软件包，由于包的数量可能非常多，所以我们需要grep命令筛选出我们所关注的包
例如：

[hxx@iZf8z3j2ckkap6xzzskbqpZ ~]$ yum list |grep lrzsz
lrzsz.x86_64 0.12.20-36.el7 @base
注意事项：
软件包名称: 主版本号.次版本号.源程序发行号-软件包的发行号.主机平台.cpu架构.
“x86_64” 后缀表示64位系统的安装包, “i686” 后缀表示32位系统安装包. 选择包时要和系统匹配.
“el7” 表示操作系统发行版的版本. “el7” 表示的是 centos7/redhat7. “el6” 表示 centos6/redhat6.
最后一列, base 表示的是 “软件源” 的名称, 类似于 “小米应用商店”, “华为应用商店” 这样的概念

1.4如何安装软件

指令格式：
[sudo/root]yum install [-y] XXX
通过系统指定路径下的yum配置文件(含有目标服务器的地址链接)来安装所需要的软件
yum会自动找到有哪些软件包需要下载，这时输入 y 确认安装，出现complete，说明安装成功

安装软件时，由于需要向系统目录中写入内容，一般需要sudo或者切换到root账户下才能完成。
yum安装软件只能装完了才能装另一个，yum正在安装一个软件的过程中，如果尝试用yum安装另一个软件，yum就会报错

1.5如何卸载软件以及yum的配置

卸载指令：
[sudo/root] yum remove [-y] XXX

安装yum的同时也会安装yum的配置文件 例如：

[hxx@iZf8z3j2ckkap6xzzskbqpZ ~]$ ls /etc/yum.repos.d/(yum的配置文件)
CentOS-Base.repo(基本软件源，很稳定) epel.repo(扩展软件源) epel.repo.rpmnew epel-testing.repo
以上是yum配置文件中的软件源，我们所需要的软件包基本上都是来自于这些软件源

yum会根据/etc/yum.repos.d/该路径下面的配置文件，来构建自己地下载链接，(根据操作系统的版本，根据你要下载的软件)，yum帮助我们下载安装

一般的机器，内置的链接是centos官网的链接，软件的链接都是指向国外的，所以yum可能比较慢，所以如何配置？
本质是更改文件/更改文件内容
下载:wget -O /etc/yum.repos.d/CentOS-Base.repo http://mirrors.aliyun.com/repo/Centos-7.repo
将Centos-7.repo这个文件下载到上述路径，并改名为Centos-7.repo
清除缓存，生成缓存，升级更新:
yum clean all
yum makecache
yum -y update

总结：
使用yum一般都是要联网的
wget http:mirror…/Centos -7.repo wget用于下载相关文件
别人可以让我们下载网站上的文件，是因为别人已经搭建好了相关的服务
解释一下企业选择centos的原因：
开源的社区比较活跃，文档齐全，问题暴露明显，有一大批开发者愿意在这个系统下免费开发，同时一些大公司也会选用这个系统，所以会存在一些企业级的应用场景暴露出来，以上也是centos的生态

2.Linux编辑器 vim

2.1 vim的基本概念

vim是一款多模式的编辑器
多模式主要包括命令模式，插入模式和底行模式

插入模式：编辑模式
命令/正常/普通模式：
允许用户使用命令，来进行文本的编辑控制
底行模式：
文档的保存或退出，也可以进行文件的替换，找到目标内容，列出行号等操作。在命令模式下，shift+；即可进入该模式。

2.2 vim的基本操作

进入vum，在系统提示符输入vim 文件名之后，就进入vim全屏幕编辑界面：

vim test.c
进入vim之后，是处于命令/正常模式,你要切换到插入模式才能输入文字

[正常模式]切换到[插入模式]

输入 a/i/o均可进入插入模式

[插入模式]切换到[正常模式]

按[Esc]就可以从插入模式退出到命令模式中

[正常模式]切换至[底行模式]

shift+；

退出vim及保存文件，在命令模式下，按：可以进入底行模式
例如：

：w 保存当前文件
：wq 保存文件并退出
：q！不保存强制退出

2.3 vim正常/命令模式命令集

移动光标：

vim可以直接使用键盘上的光标来上下左右，但是正规的vim使用小写字母h j k l来分别控制左，下，上，右移一格
shift + g：将光标移动到整个文本的末尾
n+shift+g：将光标定位到任意一行
gg：将光标移动到整个文本的最开始
shift + 4=$：将光标移动到所在行的结尾
shift + 6=^:将光标移动到所在行的起始
w：按照单词为单位进行光标后移，移到下个单词的开头
e：按照单词为单位进行光标后移，移到下个单词的结尾
b: 按照单词为单位进行光标前移，移到上个单词的开头
n+l：将光标移动到该行的第#个位置，如5l
按ctrl+b：屏幕往“后”移动一页
按ctrl+f：屏幕往“前”移动一页
按ctrl+u：屏幕往“后”移动半页
按ctrl+d：屏幕往“前”移动半页

删除文字：

n+x：删除光标之后的n个字符，默认为1，在一行之内
n+shift+x：删除光标之前的n个字符，默认为1，也是在一行之内
n+dd：从光标所在行删除连续的多行，默认为1

复制：

yw：将光标所在之处到字尾的字符复制缓冲区中
n+yw:复制n个字到缓冲区
n+yy：从光标所在行复制n行到缓冲区中，默认为一行
n+p：将缓冲区中的字符粘贴到当前光标的下一行，n表示把指定内容粘贴n次，默认为1

替换：

n+r对光标指定位置，进行一个或多个字符的替换
shift+r进入替换模式，直接进行文本替换，Esc退出

撤销上一次操作：

u：如果你误执行一个命令，可以马上按u，回到上一次操作，也可以按多次u进行多次恢复
ctrl+r对历史撤销进行撤销(一旦退出，就无法进行)

跳转指定行：

ctrl+g列出光标所在行的行号
n+shift+g表示移动光标至指定行

批量化注释和批量化去注释：

注释：ctrl+v hjkl区域选择，shift+i,//，esc*2
去注释：ctrl+v区域选择，仅包含//，d删除

2.4 vim底行模式命令集

在使用底行模式之前，请先esc确定你已经处于正常模式，在按：进入底行模式
列出行号：

set nu 会在文件中的每一行前面列出行号

跳到文件中的某一行

n n表示一个数字 输入一个数字之后按回车就跳到对应行了

查找字符:

/或者？+关键字，如果第一次不是我们想要的，按数字就可以一直找到我们想要的字符

！command：不退出vim，可以进行shell命令的执行，常用作函数查看
vim+新文件名 如果不保存就不会创建该文件
vs filename 分屏，可多文件操作
ctrl ww进行切屏

2.5 vim的简单配置

配置文件的位置：

在目录 /etc/ 下面，有个名为vimrc的文件，这是系统中公共的vim配置文件，对所有用户都有效。
而在每个用户的主目录下，都可以自己建立私有的配置文件，命名为：“.vimrc”。例如，/root目录下，
通常已经存在一个.vimrc文件,如果不存在，则创建之。
切换用户成为自己执行 su ，进入自己的主工作目录,执行 cd ~
打开自己目录下的.vimrc文件，执行 vim .vimrc

设置配置选项用来测试：

设置语法高亮: syntax on
显示行号: set nu
设置缩进的空格数为4: set shiftwidth=4

3.Linux编译器 gcc/g++

3.1 背景知识

一个源程序要变为可执行程序一般要经过4个过程，分别是：
1.预处理 2.编译 3.汇编 4.链接
Linux不关心后缀，但是编译器需要对文件后缀进行识别，然后才能编译
一般情况下，c语言编译器后缀一般设置为.c
c++文件后缀一般设置为.cc/.cpp/.cxx
例子：
gcc test.c -o you.exe -std=c99//将test.c编译之后形成的可执行程序重命名为you.exe
Linux c/c++头文件位于/usr/include

3.2 gcc如何完成？

格式：gcc [选项] [要编译的文件] [选项][目标文件]

预处理：

主要功能：主要进行宏替换，头文件展开(将头文件拷贝到源代码中)，条件编译(可以对代码的功能进行删减)以及去注释等
实例：gcc -E test.c -o test.i
解释：从现在开始进行程序的翻译，预处理完成，就停下来，同时注意的是预处理结束后的代码仍然是c程序
gcc -D V2=1 proj.c 将V2=1定义到源代码中，常常用于条件编译，来实现功能的删减

编译：

主要功能：进行语法检查，并将c程序翻译成汇编程序
实例：gcc -S test.i -o test.s
解释：从现在开始进行程序的编译，编译完成，就停下来，最后生成汇编代码

汇编：

主要功能是：将汇编程序翻译为二进制目标文件
实例：gcc -c test.s -o test.o
解释：从现在开始进行程序的翻译，汇编完成就停下来
test.o现在还不能执行，因为它还不是一个可执行文件，所以要执行一个文件，1.文件有x权限2.文件是一个可执行文件

链接：

主要功能：将库文件(c标准库)与二进制目标文件进行链接形成可执行程序
实例：gcc test.o -o my.exe

记忆小技巧：

gcc的命令选项依次是：E S c
所形成的文件后缀依次是：i s o

3.3 函数库

我们C程序中，并没有定义printf的函数的实现，且在预编译中包含的stdio.h中也只有函数的声明，而没有定义函数，那么是在哪实现printf函数的呢？
答案是：系统把这些函数实现都被放到名为libc.so.6的库文件中了，在没有指定时，gcc会到系统默认的搜索路径/usr/lib下进行查找，也就是链接到libc.so.6库函数中，这样就能实现printf函数，这也是链接的作用

函数库一般分为动态库(.so)和静态库(.a)两种
因此链接时的两种方式，动态链接和静态链接

静态链接是指编译链接时，把库文件的代码全部拷贝到可执行程序中，因此生成的文件比较大，但在运行也就不再需要库文件了，其后缀为.a

动态链接是指在编译链接时并没有把库中的代码加入到可执行程序中，而是在程序运行时 去链接对应的库，这样就可以节省系统的开销。动态库的后缀名为.so上述的libc.so.6就是动态库，gcc在编译时默认使用动态库，完成链接之后，gcc就可以生成可执行文件
gcc默认生成的二进制程序，是动态链接的，这点可以通过file命令验证

gcc选项：

-E 只激活预处理,这个不生成文件,你需要把它重定向到一个输出文件里面
-S 编译到汇编语言不进行汇编和链接
-c 编译到目标代码
-o 文件输出到 文件
-static 此选项对生成的文件采用静态链接
-g 生成调试信息。GNU 调试器可利用该信息。
-shared 此选项将尽量使用动态库，所以生成文件比较小，但是需要系统由动态库.
-O0
-O1
-O2
-O3 编译器的优化选项的4个级别，-O0表示没有优化,-O1为缺省值，-O3优化级别最高
-w 不生成任何警告信息。
-Wall 生成所有警告信息。

补充：C动态库，默认提供的
gcc默认生成的可执行程序，默认采用动态链接
C动态库/标准库如果被删除，那么动态链接的程序就无法进行

windows动态库的后缀：.dll
静态库的后缀:.lib

动态链接的优缺点

1.动态库一旦丢失，有些程序就无法运行
2.节省资源，每次只需要链接对应的库就可以，不用拷贝库中方法

静态链接的优缺点

一旦形成可执行程序，就与库无关了
但是浪费空间资源

默认情况下，Linux一般静态库都是默认没有安装的
安装静态库：
sudo yum install -y glibc-static libstdc+±static

静态库链接的应用场景：
首先静态链接会把库中的一些方法代码拷贝到可执行程序中，所以静态链接形成的可执行程序不依赖任何库，因此如果我们想让我们的代码具有更高的跨平台性，我们就可以将我们的代码进行静态链接，这样我们的代码可以方便在其他平台上直接使用

4.Linux项目自动化构建工具 make/makefile

背景知识：

1. 一个工程中的源文件不计其数，按类型，功能，模块分别放在若干目录中，makefile定义了一系列规则来指定，哪些文件需要先编译，哪些文件需要后编译，甚至进行更复杂的功能操作
   2.makefile带来的好处就是–自动化编译，只需要一个make命令，整个工程完全自动编译，极大提高了软件开发的效率
   3.make是一个命令工具，是一个解释makefile中指令的命令工具
   4.make是一条命令，makefile是一个文件，两个搭配使用，完成项目的自动化构建

4.1 实现代码

test.c代码：

 #include<stdio.h>
  2 int main()
  3 {
  4     printf("Hello world\n");                                                       
  5     return 0;
  6 }

makefile代码：

  1 mytest(目标文件):test.c(依赖文件列表，可以是多个，也可以为空)
  //目标文件依赖与依赖文件列表中的文件，即存在依赖关系
  2     gcc -o mytest test.c(依赖方法)
  3 .PHONY:clean
  4 clean:
  5     rm -f mytest   
另一种正式写法：
$ 
/*
   bin=mytest//makefile中支持定义变量
   src=test.c	
  1 $(bin) $(src)
  2     @gcc -o $@ $^//$表示取内容 @表示目标文件 ^表示依赖文件
  		@echo“$(bin)to$(src)...”
  3 .PHONY:clean
  4 clean:
  5     @rm -f	$(bin)
  		@echo"clean project..."
  //在依赖方法在前加@，在执行make的时候就不需要打印命令了
  //依赖关系不止一条

*/  

解释：
make会根据makefile的内容完成编译/清理工作
.PHONY:XXX XXX对应的方法，总是要实现的
make命令从上到下依次匹配，所以首先会默认形成一个目标文件
1.为什么makefile对最新的可执行程序吗，默认不想重新形成呢？
为了提高编译效率
2.makefile怎么做到？也就是makefile怎么知道我们的程序需要被编译呢？
是通过，可执行文件最近修改时间和源文件最近修改的时间，谁更新？如果可执行文件最新那就不需要编译了，但是如果源文件最新，那就make就会通过相应的方法对可执行文件重新形成

make会根据makefile中文件的依赖关系，进行自动推导，帮助我们执行所有相关的依赖方法
一般情况下，我们将我们所需要的目标文件放在开头，其余的文件位置可以任意

  1	 test.exe:test.o
  2     gcc  test.o -o test.exe
  3 test.o:test.s
  4     gcc -c test.s -o test.o
  5 test.s:test.i
  6     gcc -S test.i -o test.s
  7 test.i:test.c
  8     gcc -E test.c -o test.i
  9 .PHONY:clean
 10 clean:
 11     rm -f test.exe test.i test.s test.s test.o 

4.2 原理

1.make会在当前目录下找名字叫做Makefile或makefile的文件
2.如果找到，它就会找文件中的第一个目标文件，在上述例子中，它会找到text.exe这个文件，并把这个文件作为最终的目标文件
3.如果test.exe文件不存在，或test.exe所依赖的后面的.test.o文件的修改时间要比test.exe这个文件还要新(可以用touch检测)，那么，他就会执行后面所定义的命令来生成test.exe这个文件
4.如果test.exe所依赖的test.o文件不存在，那么make会在当前文件寻找目标文件为test.o的文件依赖性，如果找到，则再根据这个规则依次推导，直到能够生成最终所需要的目标文件为止
5.这个就是make的依赖性，make会一层一层的去找文件的依赖关系，直到最终编译出第一个目标文件
6.在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会退出，并报错，而对于所定义的命令的错误，或者编译不成功make根本不关心
7.make只管文件的依赖性，即，如果我们找到文件的依赖关系之后，冒号后面的文件在还是不在，make就不会进行工作了

项目清理

工程是需要被清理的
像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令就不会被自动执行，不过，我们可以显示make clean，以此来清理所有的目标文件，以便重新编译
一般情况下，我们会把clean的目标文件设置成伪目标，用.PHONY修饰，其特性是从是被执行

5.Linux第一个小程序-进度条

先介绍两个概念：
1.回车和换行

换行：是从当前行换到下一行(\n)
回车：回到一行的起始位置(\r)
所以我们之前的所说的回车键是两个动作

2.缓冲区

#include<stdio.h>
#include<unistd.h>
int main()
{
	printf("Hello World");
	sleep(3);
	return 0;
}

首先上述c代码一定是从上向下依次执行的，但是程序先会sleep3秒，然后再打印，在sleep期间，字符串是在缓冲区（一块内存空间）中，在程序结束的时候，一般要自动刷新缓冲区，也就是将内容显示在显示器中
还有几种刷新的方式：
/n，（在\n之前的所在行的内容会被刷新）
缓冲区中满的时候
强制刷新 fflush stdout
在执行程序的过程中，程序会默认打开文件的标准输入，输出，错误流，方便文件的输入和输出
补充：在我们输入数据的时候，会给程序一份，也会给程序一份

为了创建我们的一个进度条我们需要创建四个文件分别是Main.c,Processbar.h,Procseebar.c，以及makefile(用于我们对应的编译和清理工作)
Processbar.h:

#include<stdio.h>
void proc();

Processbar.c:

	1 #include"Processbar.h"
    2 #include<string.h>
    3 #include<unistd.h>
    4 #define lenth 101
    5 #define style '#'
    6 //verson1
    7 const char* lable="|/-\\";                                                             
    8 void proc() 
    9  {   char bar[lenth]; 
   10     memset(bar,'\0',sizeof(bar)); 
   11     int len=strlen(lable); 
   12     int cnt=0; 
   13     while(cnt<=100) 
   14     { 
   15         printf("[%-100s][%3d%%][%c]\r",bar,cnt,lable[cnt%len]); 
   16         fflush(stdout); 
   17         bar[cnt++]=style; 
   18         usleep(20000); 
   19     } 
   20     printf("\n"); 
   21 } 

Main:

#include"Processbar.h"
int main()
{
	proc();
	return 0;
}

但是通常情况下进度条一般不会单独出现，而是与一些文件下载密切相关，下面是一个文件下载(lesson_gcc)的案例：
Processbar.h:

  1 #pragma once//防止头文件重复包含 
  2 
  3 #include<stdio.h>
  4 
  5 typedef void(*callback_t)(double ,double);//函数指针，使用函数指针，方便我们进行图形化界面设计，提高代码复用性
  6 void proc(double file ,double current);
  7 void download(double t,callback_t a);//t表示下载的文件大小

Processbar.c:

  1 #include"Processbar.h"
  2 #include<string.h>
  3 #include<unistd.h>
  4 #define lenth 101
  5 #define style '#'
 23 const char* lable="|/-\\";
 24 void proc(double filesize,double current)
 25 {
 26     char bar[lenth];
 27     memset(bar,'\0',sizeof(bar));
 28     int len=strlen(lable);
 29     int cnt=0;
 30     double rate=(current*100)/filesize;
 31     int loop_cnt=(int)rate;
 32     while(cnt<=loop_cnt)
 33     {
 34         bar[cnt++]=style;
 35     }
 36     printf("[%-100s][%.1lf%%][%c]\r",bar,rate,lable[cnt%len]);
 37     fflush(stdout);
 38 }
 39 
 40  double bandwidth=1024*1024*1.0;//带宽
 41 void download(double filesize,callback_t cb)
 42 {                                                                                                                                                                 
 43     double current=0.0;
 44     printf("download begin,current:%lf\n",current);
 45     while(current<=filesize)
 46     {
 47         cb(filesize,current);
 48         //从网络中获取数据
 49         current+=bandwidth;
 50         usleep(20000);
 51     }
 52     printf("\n");
 53     printf("download done ,filesize:%lf\n",filesize);
 54 
 55 }

Main:

 1 #include"Processbar.h"
  2 
  3 int main()
  4 {
  5     //proc(100.0,55.3);
  6     //proc(100.0,0.3);
  7     //proc(100.0,20.3);
  8     //proc(100.0,10.3);
  9     //proc(100.0,34.3);
 10     //proc(100.0,67.3);
 11     //proc(100.0,99.3); 
 12      download(100*1024*1024,proc);
 13      download(59*1024*1024,proc);
 14      download(10*1024*1024,proc);
 15      download(16*1024*1024,proc);
 16      download(59*1024*1024,proc);
 17      download(19*1024*1024,proc);
 18      download(80*1024*1024,proc);
 19      download(110*1024*1024,proc);
 20      download(10*1024*1024,proc); //进行多文件的下载                                                       
 21 }

makefile：

1 processbar: Main.c Processbar.c
  2     gcc -o $@ $^                                                                         
  3 .PHONY:clean
  4 clean:
  5     rm -f processbar

6.git简单使用

git是一款软件，能够对我们的源代码的历史修改进行维护，保留历史的所有修改痕迹
gitee&&github都是基于git搭建起来的一个网站，能够让我们可视化的进行操作，简单可以理解我们的代码仓库

git的安装命令：

sudo yum install -y git

那么我们如何在本地建立仓库(目录)，同时与我们远端的代码仓库进行同步呢？？
下面我会在gitee上创建一个仓库进行举例：

如图首先我们先点击右上角的新建仓库，创建我们所需的仓库类型，最后点击创建

然后这就是我们创建完成的图片
接下来通过xshell来在我们的服务器上创建对应的目录，也就是我们所说的仓库

然后按照提示要求进行配置，在本地创建一个目录。

配置完毕后，test目录就是一个我们在本地创建的一个仓库，然后我们在该目录中加入一些其他的文件。
然后进行以下三个操作完成本地仓库与远端仓库的同步：
1.git add .
是将克隆仓库的变化保存在git仓库的暂存区
2.git commit -m “日志”(日志不能乱写，一般根据变化的内容进行修改)
是将目录中的变化，在git仓库中更新
3.git push
将本地仓库与远端仓库进行同步
进行上述操作之后，我们在gitee上的仓库就与我们在本地上的仓库实现同步

补充：
git log显示日志
git rm+文件名 将对应的文件从仓库中删除
git stasus
对于不想同步到本地仓库，以及远端仓库的文件，我们可以将后缀加入到.gitignore，所以git add和commit就直接忽略掉这些文件的变化
以上是对于git的一些简单的操作，但是对于git来说，还有一些企业级别的应用还未提及，随后我会再专门为git更新一期文章，有需要的话可以关注一下随后就会发布。

7.Linux调试器 gdb的使用

7.1背景

程序的发布方式有两种，debug模式和release模式
.
在debug模式下编译器形成的可执行程序，编译器会给器添加调试信息
而在release下却不会，同时release下生成的可执行程序一般都是给测试人员，以及最终要交付给用户，所以在release模式下生成的可执行程序不需要调试。
.
Linux gcc/g++编译出来的二进制程序，默认是release模式下的
要使用gdb调试，必须在源代码生成二进制程序的时候，加上-g选项

7.2 开始使用

gdb+可执行文件名 是对文件开始进行调试
quit /ctrl+d退出调试
我们可以写出如下代码来进行调试，方便我们的理解

 1 #include<stdio.h>                                                                         
  2 
  3 int add_test(int a,int b)
  4 {
  5     int i=a;
  6     int sum=0;
  7     for(;i<=b;i++)
  8     {
  9        sum+=i;
 10     }
 11     return sum;
 12 }
 13 int main()
 14 {
 15     printf("test begin!\n");
 16 
 17     int result=add_test(1,100);
 18     printf("test result :%d\n",result);
 19 
 20     printf("test done!\n");
 21     return 0;
 22 }

list/l+文件名:行号/函数名，l行号/函数名：显示源代码，连续按，就接着上次的位置往下列，每次列10行
b+文件名:行号/函数名，b：行号/函数名 ：在对应的行或者函数的起始位置打上断点
info/i ：info b查看断点
d +断点编号：删除断点

disable 断点编号：关闭断点
enable 断点编号：重新开启断点

next/n：逐过程调试代码 类似与F10
step/s：逐语句调试代码 类似于F11

printf/p+a/&a：单次查询某个变量以及某个变量的地址
display+a/&a:常显示某个变量
undisplay+常显示编号：取消常显示某个变量
continue/c运行至下一个断点处
finish：一键运行完一个函数，显示返回值
until：在一个函数中，跳转至指定行，同时中间的代码都是运行的

info local 查看函数栈帧中变量的值
set var i=100

bt显示出栈中函数的调用情况
总结：断点的本质就是帮助我们缩小出问题的范围

总结

`以上就是有关Linux工具的详细使用，如果有哪些出现问题的地方，请及时指出，博主会认真听取意见并做出及时调整，希望我的文章能够对你有所帮助，喜欢的话就点个赞，你的支持是我持续更新的动力。