【Linux学习】基础开发工具的使用

心已赠人 2023-09-28 18:52 15阅读 0赞

### 文章目录 ###

*  前言
 *  一、Linux编译器 — gcc/g++的使用
 *   *  1. gcc/g++的安装
     *  2. gcc/g++编译
     *   *  编译指令
         *  编译过程
         *  函数库
     *  3. gcc/g++编译选项
 *  二、Linux调试器 — GDB的使用
 *   *  1、什么是GDB
     *  2. GDB常用调试命令
 *  三、Linux项目自动化构建工具 — make/Makefile的使用
 *   *  1. make/makefile背景
     *  2. 实例
     *  3. make 的工作原理

# 前言 #

Windows 下有例如 Visual Studio、IDEA 这样的集编写代码、编译代码、调试代码、运行代码、代码关系维护以及各种各样的复杂功能于一身的开发工具，叫做集成开发环境 IDE。而Linux 下一般使用代码编辑工具 vi/vim，编译工具 gcc/g++，调试工具 gdb。[（vim的使用）][vim]

# 一、Linux编译器 — gcc/g++的使用 #

## 1. gcc/g++的安装 ##

root用户：

> yum install -y gcc-c++

## 2. gcc/g++编译 ##

### 编译指令 ###

> 格式：gcc/g++ 【选项】【要编译的文件】【选项】【目标文件】

### 编译过程 ###

1.  预处理（进行宏替换）

> 预处理功能主要包括宏定义,文件包含,条件编译,去注释等。  
> 预处理指令是以\#号开头的代码行。  
> 实例: gcc –E hello.c –o hello.i  
> 选项“-E”,该选项的作用是让 gcc 在预处理结束后停止编译过程。  
> 选项“-o”是指目标文件,“.i”文件为已经过预处理的C原始程序。

1.  编译（生成汇编）

> 在这个阶段中,gcc 首先要检查代码的规范性、是否有语法错误等,以确定代码的实际要做的工作,在检查无误后,gcc 把代码翻译成汇编语言。  
> 用户可以使用“-S”选项来进行查看,该选项只进行编译而不进行汇编,生成汇编代码。  
> 实例: gcc –S hello.i –o hello.s

1.  汇编（生成机器可识别的代码）

> 汇编阶段是把编译阶段生成的“ .s ”文件转成目标文件  
> 读者在此可使用选项“-c”就可看到汇编代码已转化为“.o”的二进制目标代码了  
> 实例: gcc –c hello.s –o hello.o

1.  链接（生成可执行文件或者库文件）

> 在成功编译之后,就进入了链接阶段。  
> 实例: gcc hello.o –o hello

### 函数库 ###

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

**函数库一般分为静态库和动态库两种。**

>  *  静态库是指编译链接时,把库文件的代码全部加入到可执行文件中,因此生成的文件比较大,但在运行时也就不再需要库文件了。其后缀名一般为“.a”
>  *  动态库与之相反,在编译链接时并没有把库文件的代码加入到可执行文件中，而是在程序执行时由运行时链接文件加载库，这样可以节省系统的开销。动态库一般后缀名为“.so”，如前面所述的 libc.so.6 就是动态库。gcc 在编译时默认使用动态库。完成了链接之后，gcc 就可以生成可执行文件。如：gcc hello.o –o hello

## 3. gcc/g++编译选项 ##

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

# 二、Linux调试器 — GDB的使用 #

## 1、什么是GDB ##

GDB 全称“GNU symbolic debugger”，从名称上不难看出，它诞生于 GNU 计划（同时诞生的还有 GCC、Emacs 等），是 Linux 下常用的程序调试器。发展至今，GDB 已经迭代了诸多个版本，当下的 GDB 支持调试多种编程语言编写的程序，包括 C、C++、Go、Objective-C、OpenCL、Ada 等。实际场景中，GDB 更常用来调试 C 和 C++ 程序。

**GDB主要帮助你完成下面四个方面的功能：**

>  *  按照自定义的方式启动运行需要调试的程序。
>  *  可以使用指定位置和条件表达式的方式来设置断点。
>  *  程序暂停时的值的监视。
>  *  动态改变程序的执行环境。

【注意】

>  *  程序的发布方式有两种，debug模式和release模式
>  *  Linux gcc/g++出来的二进制程序，默认是release模式
>  *  要使用GDB调试，必须在源代码生成二进制程序的时候, 加上 -g 选项

## 2. GDB常用调试命令 ##

1.  基础命令

<table> 
 <thead> 
  <tr> 
   <th>命令</th> 
   <th>简写</th> 
   <th>功能</th> 
   <th>备注</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>list</td> 
   <td>l</td> 
   <td>显示binFile源代码</td> 
   <td>l 后面加上行号或者函数名，每次显示10行代码或者某个函数的源码</td> 
  </tr> 
  <tr> 
   <td>break</td> 
   <td>b</td> 
   <td>设置断点</td> 
   <td>b 后面加上行号，表示在该行设置断点</td> 
  </tr> 
  <tr> 
   <td>delete</td> 
   <td>d</td> 
   <td>删除断点</td> 
   <td>delete断点编号</td> 
  </tr> 
  <tr> 
   <td>disable</td> 
   <td>disable</td> 
   <td>禁用断点</td> 
   <td>disable断点编号</td> 
  </tr> 
  <tr> 
   <td>backtrace</td> 
   <td>bt</td> 
   <td>查看栈帧</td> 
   <td>bt N显示开头N个栈帧， bt -N最后N个栈帧</td> 
  </tr> 
  <tr> 
   <td>run</td> 
   <td>r</td> 
   <td>运行</td> 
   <td>调试开始</td> 
  </tr> 
  <tr> 
   <td>next</td> 
   <td>n</td> 
   <td>执行下一行</td> 
   <td>执行到下一行，不管下一行多复杂</td> 
  </tr> 
  <tr> 
   <td>step</td> 
   <td>s</td> 
   <td>执行下一行</td> 
   <td>若下一行为函数，则进入函数内部</td> 
  </tr> 
  <tr> 
   <td>info</td> 
   <td>i</td> 
   <td>查看信息</td> 
   <td>查看断点i b、或者查看当前栈帧局部变量的值</td> 
  </tr> 
  <tr> 
   <td>finish</td> 
   <td>finish</td> 
   <td>执行完当前函数</td> 
   <td>执行到当前函数返回，然后挺下来等待命令</td> 
  </tr> 
  <tr> 
   <td>print</td> 
   <td>p</td> 
   <td>打印表达式的值</td> 
   <td>通过表达式可以修改变量的值或者调用函数</td> 
  </tr> 
  <tr> 
   <td>set</td> 
   <td>set</td> 
   <td>改变变量值</td> 
   <td>set variable &lt;变量&gt; = &lt;表达式&gt;；比如 set var test=3</td> 
  </tr> 
  <tr> 
   <td>continue</td> 
   <td>c</td> 
   <td>继续</td> 
   <td>c为继续的次数，可省略，表示继续一次</td> 
  </tr> 
  <tr> 
   <td>display + 变量名</td> 
   <td></td> 
   <td>显示变量的值</td> 
   <td>跟踪查看一个变量，每次停下来都显示它的值</td> 
  </tr> 
  <tr> 
   <td>undisplay</td> 
   <td></td> 
   <td>取消对先前设置的那些变量的跟踪</td> 
   <td></td> 
  </tr> 
  <tr> 
   <td>until</td> 
   <td>until</td> 
   <td>执行完成代码块</td> 
   <td>X行号：跳至X行</td> 
  </tr> 
  <tr> 
   <td>quit</td> 
   <td>q</td> 
   <td>退出调试</td> 
   <td>ctrl+ d 也可以退出调试</td> 
  </tr> 
 </tbody> 
</table>

【注意】  
**gdb命令拥有较多内部命令。在gdb命令提示符“(gdb)”下输入“help”可以查看所有内部命令及使用说明。**  
2. 打印变量值

print支持格式化输出，命令格式：p 【格式】 【变量】

支持的格式如下：

<table> 
 <thead> 
  <tr> 
   <th>格式</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>x</td> 
   <td>显示为16进制</td> 
  </tr> 
  <tr> 
   <td>d</td> 
   <td>显示为10进制</td> 
  </tr> 
  <tr> 
   <td>u</td> 
   <td>显示为无符号10进制</td> 
  </tr> 
  <tr> 
   <td>o</td> 
   <td>显示为8进制</td> 
  </tr> 
  <tr> 
   <td>t</td> 
   <td>显示为2进制数，t表示two</td> 
  </tr> 
  <tr> 
   <td>a</td> 
   <td>地址</td> 
  </tr> 
  <tr> 
   <td>c</td> 
   <td>显示为字符</td> 
  </tr> 
  <tr> 
   <td>f</td> 
   <td>浮点小数</td> 
  </tr> 
  <tr> 
   <td>s</td> 
   <td>显示为字符串</td> 
  </tr> 
 </tbody> 
</table>

用以下代码进行调试演示：

#include<stdio.h>
    
    int AddToTop(int top)
    {
        
       int res = 0;
       for(int i = 1; i <= top; ++i)
       {
        
           res += i;
       }
       return res;
    }
    
    int main()
    {
        
       int res = 0;
       int top = 100;
       res = AddToTop(top);
    
       printf("result = %d\n", res);
       return 0;
    }

Linux gcc/g++出来的二进制程序，默认是release模式。用 gcc test.cpp -o test 编译时：

![d6ec3db1cf33438f946b8a657d1ff64e.png][]  
要调试C/C++的程序，首先在编译时，要使用gdb调试程序，在使用gcc编译源代码时必须加上“-g”参数。保留调试信息，否则不能使用GDB进行调试。

gcc test.c -o test_g -g

![608ecfa7fb954147b1fcd3c501e679f5.png][]  
此时便可以进行调试。

# 三、Linux项目自动化构建工具 — make/Makefile的使用 #

## 1. make/makefile背景 ##

*  会不会写makefile，从一个侧面说明了一个人是否具备完成大型工程的能力。一个工程中的源文件不计数，其按类型、功能、模块分别放在若干个目录中，makefile定义了一系列的规则来指定，哪些文件需要先编译，哪些文件需要后编译，哪些文件需要重新编译，甚至于进行更复杂的功能操作
 *  makefile带来的好处就是——“自动化编译”，一旦写好，只需要一个make命令，整个工程完全自动编译，极大的提高了软件开发的效率。
 *  make是一个命令工具，是一个解释makefile中指令的命令工具，一般来说，大多数的IDE都有这个命  
    令，比如：Delphi的make，Visual C++的nmake，Linux下GNU的make。可见，makefile都成为了一种在工程方面的编译方法。
 *  make是一条命令，makefile是一个文件，两个搭配使用，完成项目自动化构建。

## 2. 实例 ##

#include <stdio.h>
    int main()
    {
        
    	printf("hello Makefile!\n");
    	return 0;
    }

Makefile文件：

hello:hello.o
    	gcc hello.o -o hello 
    hello.o:hello.s
    	gcc -c hello.s -o hello.o
    hello.s:hello.i 
    	gcc -S hello.i -o hello.s
    hello.i:hello.c 
    	gcc -E hello.c -o hello.i
    .PHONY:clean
    clean:
    	rm -f hello.i hello.s hello.o hello

**依赖关系:**

> 上面的文件 hello ,它依赖 hell.o  
> hello.o , 它依赖 hello.s  
> hello.s , 它依赖 hello.i  
> hello.i , 它依赖 hello.c

**依赖方法:**

> gcc hello.\* -option hello.\* ，就是与之对应的依赖关系

## 3. make 的工作原理 ##

*  make是如何工作的,在默认的方式下，也就是我们只输入make命令。那么，就会自动进行以下过程：

> 1.  make会在当前目录下找名字叫“Makefile”或“makefile”的文件。
> 2.  如果找到，它会找文件中的第一个目标文件（target），在上面的例子中，他会找到“hello”这个文件，并把这个文件作为最终的目标文件。
> 3.  如果hello文件不存在，或是hello所依赖的后面的hello.o文件的文件修改时间要比hello这个文件新（可以用 touch 测试），那么，他就会执行后面所定义的命令来生成hello这个文件。
> 4.  如果hello所依赖的hello.o文件不存在，那么make会在当前文件中找目标为hello.o文件的依赖性，如果找到则再根据那一个规则生成hello.o文件。（这有点像一个堆栈的过程）
> 5.  当然，你的C文件和H文件是存在的啦，于是make会生成 hello.o 文件，然后再用 hello.o 文件声明make的终极任务，也就是执行文件hello了。
> 6.  这就是整个make的依赖性，make会一层又一层地去找文件的依赖关系，直到最终编译出第一个目标文件。
> 7.  在找寻的过程中，如果出现错误，比如最后被依赖的文件找不到，那么make就会直接退出，并报错，而对于所定义的命令的错误，或是编译不成功，make根本不理。
> 8.  make只管文件的依赖性，即，如果在我找了依赖关系之后，冒号后面的文件还是不在，那么对不起，我就不工作啦。

*  清理工作：

>  *  像clean这种，没有被第一个目标文件直接或间接关联，那么它后面所定义的命令将不会被自动执行，不过，我们可以显示要make执行。即命令——“make clean”，以此来清除所有的目标文件，以便重编译。
>  *  但是一般我们这种clean的目标文件，我们将它设置为伪目标,用 .PHONY 修饰,伪目标的特性是，总是被执行的。

[vim]: https://blog.csdn.net/qq_61635026/article/details/125667214
[d6ec3db1cf33438f946b8a657d1ff64e.png]: https://img-blog.csdnimg.cn/d6ec3db1cf33438f946b8a657d1ff64e.png
[608ecfa7fb954147b1fcd3c501e679f5.png]: https://img-blog.csdnimg.cn/608ecfa7fb954147b1fcd3c501e679f5.png