【Linux详解】——gcc/g++/gdb/git的使用

前言：本期将学习gcc/g++/gdb/git的使用

---

1. 程序的翻译过程

1. 预处理（头文件展开，去注释，宏替换，条件编译）
2. 编译：把C变成汇编语言
3. 汇编：把汇编变成二进制（不是可执行，二进制目标文件不能被执行）
4. 链接：把你下的代码和C标准库中的代码合起来

2. 理解选项的含义

首先输入一段测试代码

#include
#define M 666
int main()
{            
	// 测试注释
	printf("Hello 1\n");
	// printf("Hello 1\n");                                                
	// printf("Hello 2\n");
	// printf("Hello 3\n");
	// printf("Hello 4\n")   
	printf("Hello 5\n");   
                 
	//测试条件编译
#ifdef SHOW             
	printf("Hello show!\n");
#else             
	printf("Hello default\n");
#endif                      
    // 测试宏                 
   	printf("宏：%d\n", M);
   	return 0;
}            

直接执行会一步到位输出结果

[hins@VM-12-13-centos testLinux]$ vim test.c
[hins@VM-12-13-centos testLinux]$ gcc test.c
[hins@VM-12-13-centos testLinux]$ ll
total 16
-rwxrwxr-x 1 hins hins 8408 Oct 29 12:04 a.out
-rw-rw-r-- 1 hins hins  414 Oct 29 12:03 test.c
[hins@VM-12-13-centos testLinux]$ ./a.out
Hello 1
Hello 5
Hello default
宏：666

但是我们要理解上面四个过程，就要划分成四条指令依次执行上述的四步翻译过程，在此期间理解选项的含义。

1. 预处理： gcc -E test.c -o test.i，其中-E表示从现在开始，进行程序的翻译，当将预处理做完，就停下来。-o指明形成的临时文件名称
   
2. 编译： gcc -S test.i -o test.s，把C语言转成汇编语言
3. 汇编： gcc -c test.s -o test.o，把汇编语言变成可重定向目标二进制文件。od test.o：打开二进制文件。
4. 链接： gcc test.o -o test.out，形成可执行二进制程序（库+你的代码）

3. 动态链接和静态链接

首先我们要清楚，我们自己写的代码和库是两码事。C标准库是别人给我们准备好的，让我们直接使用的。我们所有使用库中函数的代码（如printf()），其中我们自己只写了该函数的调用，没有对应的实现！只有当链接的时候，对应的实现才和我们的代码关联起来！

那么这就引入了链接，链接的本质：就是我们调用库函数的时候和标准库如何关联的问题。这种关联就包括动态和静态。

• 动态链接： 受库升级或者被删除的影响，形成的可执行程序小，节省资源。
• 静态链接： 不受库升级或者被删除的影响，形成的可执行程序较大！ – 网络，磁盘，内存

在Linux下库的命名：

• 动态库：lib XXX.so 例：libc.so.6就是c标准库
• 静态库：lib XXX.a

在Windows下：

• 动态库：.dll
• 静态库：.lib

当我们执行查看c标准库的时候，就可以看到具体的信息，并发现此标准库默认是.so结尾的动态库。

[hins@VM-12-13-centos testLinux]$ ls /lib64/libc.so.6 -l
lrwxrwxrwx 1 root root 12 Jul 25 16:58 /lib64/libc.so.6 -> libc-2.17.so
[hins@VM-12-13-centos testLinux]$ ls /lib64/libc-2.17.so -al
-rwxr-xr-x 1 root root 2156592 May 19 00:18 /lib64/libc-2.17.so

对于动态库和静态库来说，动态库是系统自带的，即系统安装完毕就可以使用，而静态库则一般需要我们自己安装，这也说明了静态库并不是直接拷贝动态库的内容。因此我们需要手动安装一下静态库：sudo yum install -y glibc-static

安装静态库之后，我们就可以通过 在已有的指令基础上加上-static指定静态库编译：

[hins@VM-12-13-centos testLinux]$ gcc test.c -o test2.s -static	# 静态编译指令
-rwxrwxr-x 1 hins hins   8360 Oct 29 20:41 test1.s # 动态编译
-rwxrwxr-x 1 hins hins 861288 Oct 29 20:41 test2.s # 静态编译

[hins@VM-12-13-centos testLinux]$ file test1.s
test1.s: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked (uses shared libs), for GNU/Linux 2.6.32, BuildID[sha1]=0d515023c156fe158cca3be209a14ff5924814e1, not stripped

[hins@VM-12-13-centos testLinux]$ file test2.s
test2.s: ELF 64-bit LSB executable, x86-64, version 1 (GNU/Linux), statically linked, for GNU/Linux 2.6.32, BuildID[sha1]=0c504898c44f70be42f625ac057dbc6ed3cae69b, not stripped

安装C++版本的gcc(g++)：sudo yum install -y gcc-c++

安装C++静态库：sudo yum install -y libstdc++-static

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

4.1 背景

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

4.2 使用

对于makefile，若想利用make命令，则必须创建makefile命名的文件（m大写也可），在内部编写一定的依赖规则之后，我们通过make就可以对应的执行程序，就省略了类似于这种gcc test.c -o test的编译指令，我们来看看如何操作：

[hins@VM-12-13-centos testLinux]$ touch makefile # 创建一个makefile文件
[hins@VM-12-13-centos testLinux]$ vim makefile # 编辑内部依赖关系
# 写入下面指令
mycode:mycode.c		# 依赖关系：即生成的mycode是依赖mycode.c实现的
	gcc mycode.c -o mycode		# 依赖方法：即上述我们需要省略的gcc指令，必须以Tab键开头
.PHONY:clean		# 被.PHONY修饰的对象是一个伪目标，它总是被执行，例子在下面
clean:
	rm -f mycode
[hins@VM-12-13-centos testLinux]$ make	# 这里make默认执行第一个gcc指令，生成mycode可执行文件，指令等价于make mycode
gcc mycode.c -o mycode
[hins@VM-12-13-centos testLinux]$ ll
total 24
-rw-rw-r-- 1 hins hins   74 Oct 30 11:32 makefile
-rwxrwxr-x 1 hins hins 8360 Oct 30 11:32 mycode		# 可执行文件
-rw-rw-r-- 1 hins hins   77 Oct 29 20:39 mycode.c

[hins@VM-12-13-centos testLinux]$ ./mycode
Hello World!		# 输出结果

[hins@VM-12-13-centos testLinux]$ make	# 重复执行make指令
make: `mycode' is up to date.		# 提示已是最新，不用再编译，原因是mycode.c没有任何修改

[hins@VM-12-13-centos testLinux]$ make clean  # 执行clean对象
rm -f mycode
[hins@VM-12-13-centos testLinux]$ ll
total 12
-rw-rw-r-- 1 hins hins  74 Oct 30 11:32 makefile
-rw-rw-r-- 1 hins hins  77 Oct 29 20:39 mycode.c
[hins@VM-12-13-centos testLinux]$ make clean	# mycode文件已删除，但仍能执行，原因是被.PHONY修饰的对象总是被执行
rm -f mycode

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

5.1 缓冲区概念

先运行以下两个代码

#include
int main()
{
    // 首先执行的一定是printf，代码是顺序结构
    // 先执行printf不等于数据先显示
    printf("Heeeeello!\n");		// 第一个
	printf("Heeeeello!");		// 第二个
    sleep(2);

    return 0;
}

我们发现，sleep尽管在printf语句的后面，但是执行不带\n的代码中显示器是仍然是先执行的sleep，这是什么原因呢？

实际上，这是一个行缓冲的问题，即确实在语言上先执行的printf，但却不是直接打印在显示器上，而是进入了缓冲区，而缓冲区是以\n为截止条件的，也就是说这一行中程序如果没有\n，就会暂时保留在缓冲区内部，直到出现\n或者程序执行完成。因此，上面的动图并没有直接执行printf是因为没有\n。

5.2 回车换行概念

对于回车换行，实际上是两个概念，换行\n是换到下一行，而回车\r是光标回到这一行的起始位置，因此我们键盘上的enter键称之为回车换行实际上是两个功能合并在了一起。

5.3 fflush(stdout)

因此为了解决上面的代码问题，可以用刷新缓冲区的办法实现：

#include
int main()
{
	printf("Heeeeello!\r");		
	fflush(stdout);
    sleep(2);
    return 0;
}

5.4 倒计时实现

#include
#include
int main()
{
    int cnt = 10;
    while(cnt)
    {
        printf("倒计时：%2d\r", cnt);
        fflush(stdout);
        cnt--;
        sleep(1);
    }
    return 0;
}

上述实际上有一定的细节，我们知道/r只是回到起始位置，但如果不控制格式2d，就会出现打印10,90,80……的情况，因为我们每次只覆盖了第一个位置，因此在这里要控制格式，并且fflush(stdout)。

5.5 进度条实现

对于进度条来说，通过最上面的行缓冲的知识，我们已经知道应该如何去规避了，因此在这里直接展示进度条，我将程序分成三个部分，即经典的main.c/process.c/process.h，并且将makefile中的依赖对象也改变，对于依赖对象来说，只要-o后面最靠近的是要生成的即可。

# Makefile
ProcessOn:main.c process.c 
	gcc -o ProcessOn main.c process.c -DN=3  # 利用命令行传参，选择进度条的形状

.PHONY:clean 
clean:
	rm -f ProcessOn

// process.h
#pragma once
#include
#include
#include      // usleep的头文件

#define NUM 101
#define S_NUM 5

extern void ProcessOn();  // 函数的声明

// process.c
#include"process.h"

char style[S_NUM] = {'-','.','#','>','+'};

void ProcessOn()    // 函数的定义
{
    int cnt = 0;
    char bar[NUM];

    memset(bar,'\0',sizeof(bar));

    //reverse
    const char* lable = "|\\-/";

    //101次
    while(cnt <=100)
    {
        //printf("[%-100s][%d%%][%c]\r", bar,cnt,lable[cnt%4]);
        printf("\033[42;34m[%-100s][%d%%][%c]\033[0m\r", bar,cnt,lable[cnt%4]); 		// 修改颜色
        fflush(stdout);
        bar[cnt++] = style[N];
        usleep(50000);
    }
    printf("\n");
}

颜色修改
printf(“'\033[字背景颜色;字体颜色m字符串\033[0m” ); printf(“'\033[47;31mhelloworld\033[5m”);

// main.c
#include"process.h"
int main()
{
    ProcessOn();  // 函数调用
    return 0;
}

6. git的使用

• git clone + [url]：克隆远程仓库，这里的 url 就是项目的链接.

.gitignore介绍：凡是这个文件内部的后缀，都不会被上传到gitee上的。

所谓的git仓库，本质就是一个目录，以及里面的内容。而push到远端就是将.git的内容同步到gitee上

• git add + 文件：将新增的文件添加到本地仓库
• git commit [-m] "日志"：提交，-m 后面加上提交的日志
• git push：将本地内容推送到远端
• git log：查看提交日志
• git status：查看当前状态
• git pull：把远端拉到本地同步。（如果远端和本地都同步进行修改了，起冲突了，直接先pull一下）

配置免密码提交
git本地免密码和账号pull、push

7. gdb（调试工具）的使用

Linux gcc/g++ 出来的二进制程序，默认是 release 模式
要使用 gdb 调试，必须在源代码生成二进制程序的时候 , 加上 -g 选项，这样才能进入Debug模式

安装gdb

sudo yum install -y gdb

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

准备一份测试代码

// mytest.c
#include 
#include 

void Print(int sum)
{
    long long  timestamp = time(NULL);
    printf("result = %d, timestamp: %lld\n", sum, timestamp);
}

int AddToVal(int from, int to)
{
    int sum = 0;
    for(int i = from; i < to; i++)
    {
        sum += i;
    }

    return sum;
}

int main()
{
    int sum = AddToVal(0, 100);
    printf("hello a\n");
    printf("hello b\n");
    printf("hello c\n");
    printf("hello d\n");
    printf("hello e\n");
    printf("hello f\n");
    Print(sum);
    return 0;
}

# Makefile
mytest_g:mytest.c
	gcc -o mytest_g mytest.c -g --std=c99   # gcc默认支持c89标准，若要支持c99需要加上--std=c99
.PHONY:clean
clean:
	rm -f mytest_g

进入gdb：gdb mytest_g

常见选项：

• l + 行号：从指定的行号开始往下显示源代码，每次显示10行 (l – list)；(注：gdb 有自动记忆命令的功能，即当我们第一次使用 l 显示源代码后，我们下一次再使用 l 或者下一次按下 enter 键时，它会接着上次的位置往下显示)

(gdb) l			# 每次显示10行（此处位置是随机）
warning: Source file is more recent than executable.
15	        sum += i;
16	    }
17	
18	    return sum;
19	}
20	
21	
22	int main()
23	{
24	    int sum = AddToVal(0, 100);
(gdb) l 0		# 从第1行开始显示
1	#include 
2	#include 
3	
4	void Print(int sum)
5	{
6	    long long  timestamp = time(NULL);
7	    printf("result = %d, timestamp: %lld\n", sum, timestamp);
8	}
9	
10	int AddToVal(int from, int to)
(gdb) l			# 第二次接着上次的位置往后显示
11	{
12	    int sum = 0;
13	    for(int i = from; i < to; i++)
14	    {
15	        sum += i;
16	    }
17	
18	    return sum;
19	}
20	
(gdb) 			# 使用enter键相当于执行上次的命令
21	
22	int main()

......

• l + 函数：列出某个函数的源代码 (l – list)；
• b + 行号：在某一行打一个断点，相当于VS中的F9 (b – breakpoint)；
• info b：查看断点；
• d + 断点编号：删除断点 (d – delete)；(注：每个断点都有自己的编号，我们删除断点时需要指明对应的断点编号)
• r：调试运行，如果程序中有断点，则在断点处停下来，如果没有，则直接将程序跑完，相当于VS中的F5 (r – run)；
• n：逐过程调试，相当于VS中的F10 (n – next)；
• s：逐语句调试，相当于VS中的F11 (s – step)；
• c：运行至下一个断点处停下 (c – continue)；(注：如果断点所在行不是一条语句，比如 “{” “}” 或者 空行，那么它会继续往下到有效行处停下 )
• bt：查看调用堆栈 (breaktrace)；
• p + 变量：查看变量值 (p – print)；
• display/undisplay + 变量：跟踪查看一个变量，每次停下来都显示它的值，undisplay 取消对先前设置的那些变量的跟踪；
• finish：把当前函数运行完；
• disable breakpoints：禁用断点；
• enable breakpoints：启用断点；
• until + X行号：跳至X行
• info（i) locals：查看当前栈帧局部变量的值
• quit：退出 gdb；

(gdb) b 24
Breakpoint 1 at 0x400628: file mytest.c, line 24.
(gdb) b 26
Breakpoint 2 at 0x400644: file mytest.c, line 26.
(gdb) b 31
Breakpoint 3 at 0x400676: file mytest.c, line 31.
(gdb) info b					# 查看断点信息
Num     Type           Disp Enb Address            What
1       breakpoint     keep y   0x0000000000400628 in main at mytest.c:24
2       breakpoint     keep y   0x0000000000400644 in main at mytest.c:26
3       breakpoint     keep y   0x0000000000400676 in main at mytest.c:31
(gdb) r							# 相当于VS的F5
Starting program: /home/hins/testLinux/gdb_test/mytest_g 

Breakpoint 1, main () at mytest.c:24
24	    int sum = AddToVal(0, 100);
(gdb) s							# 相当于VS的F11
AddToVal (from=0, to=100) at mytest.c:12
12	    int sum = 0;
(gdb) n							# 相当于VS的F10
13	    for(int i = from; i < to; i++)
(gdb) bt						# 查看调用堆栈
#0  AddToVal (from=0, to=100) at mytest.c:13
#1  0x0000000000400637 in main () at mytest.c:24
(gdb) display i					# 监视窗口
1: i = 0
(gdb) display sum
2: sum = 0
(gdb) 
(gdb) n
15	        sum += i;
2: sum = 0
1: i = 0
(gdb) n
13	    for(int i = from; i < to; i++)
2: sum = 0
1: i = 0
(gdb) n
15	        sum += i;
2: sum = 0
1: i = 1
(gdb) n
13	    for(int i = from; i < to; i++)
2: sum = 1
1: i = 1
(gdb) n
15	        sum += i;
2: sum = 1
1: i = 2
(gdb) n
13	    for(int i = from; i < to; i++)
2: sum = 3
1: i = 2
(gdb) finish					# 把当前函数运行完
Run till exit from #0  AddToVal (from=0, to=100) at mytest.c:13
0x0000000000400637 in main () at mytest.c:24
24	    int sum = AddToVal(0, 100);
Value returned is $1 = 4950
(gdb) n
25	    printf("hello a\n");
(gdb) c
Continuing.
hello a

Breakpoint 2, main () at mytest.c:26
26	    printf("hello b\n");
(gdb) c							# 运行至下一个断点停下
Continuing.
hello b
hello c
hello d
hello e
hello f

Breakpoint 3, main () at mytest.c:31
31	    Print(sum);
(gdb) finish
The program is not being run.

---

OK，以上就是本期知识点“gcc/g++/gdb/git的使用”的知识啦~~ ，感谢友友们的阅读。后续还会继续更新，欢迎持续关注哟~
如果有错误❌，欢迎批评指正呀~让我们一起相互进步
如果觉得收获满满，可以点点赞支持一下哟~