Linux GCC编译工具链全解析：编译/调试/库/Makefile一站式教程

前言

在Linux开发环境中，没有图形化IDE的一键编译，取而代之的是GCC编译工具链（GNU Compiler Collection），这是Linux下C/C++开发的核心工具，包含GCC编译器、GDB调试器、库管理、Makefile自动化构建四大核心模块。

本文从程序编译流程出发，逐步讲解GCC编译选项、条件编译、GDB调试、静态/动态库的创建与使用，以及Makefile自动化编译规则，覆盖Linux C/C++开发的全流程工具使用，做到从源码到可执行程序，从调试到项目构建的一站式掌握，适合Linux开发初学者入门。

核心工具：GCC（编译）、GDB（调试）、ar（静态库打包）、make（Makefile执行）
适用场景：Linux下C/C++项目开发、开源项目编译、自定义库开发、自动化项目构建

一、GCC编译器：程序编译的核心

GCC是GNU旗下的C/C++编译器，gcc针对C语言，g++针对C++语言，其核心作用是将源代码经过多阶段处理，最终生成可执行程序，同时支持灵活的编译选项配置，满足不同开发需求。

1.1 先装GCC

Ubuntu/Debian系列通过apt快速安装GCC和配套调试工具GDB：

# 安装gcc和gdb
sudo apt install gcc gdb
# 查看gcc版本，验证安装
gcc -v

1.2 程序编译的四个阶段

从C源代码（.c）到可执行程序，GCC会经过预处理、编译、汇编、链接四个阶段，每个阶段生成对应的中间文件，最终链接库文件生成可执行程序。

1.3 分阶段编译示例（以hello.c为例）

// hello.c 示例代码
#include <stdio.h>
#define MSG "Hello GCC"
int main() {
printf("%s\\n", MSG);
return 0;
}

执行以下命令，分阶段生成中间文件，最终得到可执行程序：

# 1. 预处理：生成hello.i，仅执行预处理阶段
gcc -E hello.c -o hello.i
# 2. 编译：生成hello.s，执行预处理+编译
gcc -S hello.i -o hello.s
# 3. 汇编：生成hello.o，执行预处理+编译+汇编
gcc -c hello.s -o hello.o
# 4. 链接：生成可执行程序hello，链接目标文件与系统库
gcc hello.o -o hello
# 运行可执行程序
./hello

1.4 简化编译：一步/两步到位

实际开发中无需分阶段执行，GCC支持两步编译或一步编译，自动完成所有阶段，大幅简化操作：

# 两步编译：先生成目标文件，再链接（适合多文件项目）
gcc -c hello.c # 自动生成hello.o，省略-o则默认与源文件同名
gcc hello.o -o hello # 链接生成hello，省略-o则默认生成a.out

# 一步编译：直接从.c文件生成可执行程序（适合单文件项目，最常用）
gcc hello.c -o hello

注意：默认生成的可执行程序为a.out，建议用-o指定自定义名称，避免覆盖。

1.5 GCC常用编译选项（必记）

GCC提供大量编译选项，用于控制编译过程、开启警告、生成调试信息、优化程序等，以下为开发高频使用的核心选项，搭配使用满足不同需求：

补充：通过cpp -v可查看系统默认的头文件搜索目录，-I指定的目录会优先于系统目录搜索。

二、条件编译：预处理阶段的灵活控制

条件编译是指在预处理阶段，根据预定义的宏条件，决定是否保留某段代码，最终仅将符合条件的代码交由编译器处理。核心作用是调试程序、编写可移植代码、避免头文件重复包含，是Linux开发的常用技巧。

2.1 核心预处理指令

条件编译基于4组预处理指令实现，覆盖所有条件判断场景，指令均在预处理阶段执行，不生成最终代码：

2.2 各指令用法详解

1. #if 指令：常量表达式判断

格式：

#if 常量表达式
// 表达式非0时保留的代码
[#elif 常量表达式
// 其他条件代码]
[#else
// 所有条件不满足时的代码]
#endif

核心：表达式必须是常量（预处理阶段无法计算变量），非0则保留代码，0则删除。
实战：调试程序时打印调试信息，发布时关闭：

#define DEBUG 1 // 调试时设1，发布时设0
int main() {
int i = 10;
#if DEBUG
printf("调试：i = %d\\n", i); // DEBUG=1时保留，0时删除
#endif
printf("正式代码\\n");
return 0;
}

也可通过GCC的-D选项在编译时定义宏，无需修改源码：

# 编译时定义DEBUG=1，开启调试信息
gcc test.c -o test -DDEBUG=1
# 编译时定义DEBUG=0，关闭调试信息
gcc test.c -o test -DDEBUG=0

2. defined 运算符：宏定义判断

格式：

#if defined(宏名) // 括号可省略，写成#if defined 宏名
// 宏已定义时保留的代码
#endif

核心：仅判断宏是否定义，不关心宏的值，比#if更灵活。
实战：

#define DEBUG // 仅定义，不赋值
#if defined(DEBUG)
printf("宏已定义，开启调试\\n");
#endif

3. #ifdef 指令：宏已定义判断

格式：

#ifdef 宏名
// 宏已定义时保留的代码
#endif

核心：等价于#if defined(宏名)，语法更简洁，是开发中最常用的形式。

4. #ifndef 指令：宏未定义判断

格式：

#ifndef 宏名
// 宏未定义时保留的代码
#endif

核心：与#ifdef相反，是避免头文件重复包含的核心指令。

2.3 条件编译的四大核心应用

应用1：调试程序（最常用）

通过定义DEBUG宏，在调试阶段打印变量、流程信息，发布阶段通过-DDEBUG=0或注释宏定义，自动删除调试代码，无需手动删除，提升开发效率。

应用2：编写可移植程序

根据不同操作系统（WIN32/MAC_OS/LINUX）定义不同的宏，编译时通过-D指定宏，自动保留对应操作系统的代码，实现一次编码，多平台编译：

#if defined(WIN32)
#include <windows.h>
#define PRINT "Windows系统\\n"
#elif defined(MAC_OS)
#include <CoreFoundation/CoreFoundation.h>
#define PRINT "MacOS系统\\n"
#elif defined(LINUX)
#include <stdio.h>
#define PRINT "Linux系统\\n"
#endif
int main() {
printf(PRINT);
return 0;
}

Linux下编译：

gcc test.c -o test -DLINUX

应用3：为宏提供默认定义

通过#ifndef判断宏是否未定义，若未定义则赋予默认值，避免宏未定义导致的编译错误：

#ifndef BUFFER_SIZE
#define BUFFER_SIZE 1024 // 未定义时默认1024
#endif
char buf[BUFFER_SIZE];

应用4：避免头文件重复包含

多次#include同一个头文件，会导致重复定义错误（如头文件中的结构体、宏），通过#ifndef+#define+#endif形成头文件保护，确保头文件仅被包含一次，是所有头文件的标准写法。
头文件保护模板（必记，所有自定义头文件都要加）：

// 文件名：foo.h
#ifndef __WD_FOO_H // 宏名建议：__项目名_文件名_H，避免冲突
#define __WD_FOO_H // 定义宏，标记头文件已被包含

// 头文件核心内容：结构体、函数声明、宏定义
typedef struct {
int id;
char name[20];
} Student;

int add(int a, int b);

#endif // 结束条件编译，确保仅包含一次

应用5：条件屏蔽代码

无法用/*…*/注释已包含注释的代码（注释嵌套报错），通过#if 0可实现任意代码的屏蔽，预处理阶段会直接删除#if 0与#endif之间的所有代码：

#if 0
// 被屏蔽的代码，包含注释也不会报错
int a = 10;
/* 嵌套注释 */
printf("被屏蔽的代码\\n");
#endif

三、GDB调试器：程序BUG排查神器

写程序难免出现BUG，GDB（GNU Debugger）是Linux下的命令行调试器，支持断点调试、单步执行、变量监视、栈帧查看等功能，与VS/CLion等图形化IDE的调试功能一致，是Linux开发中排查BUG的核心工具。

3.1 调试前提：编译时加-g选项

GDB调试需要源码的调试信息，因此编译时必须添加-g选项，否则GDB无法关联源码，只能调试二进制代码：

# 编译时加-g，生成带调试信息的可执行程序
gcc test.c -o test -g

3.2 启动GDB调试界面

有两种方式启动GDB，可根据是否需要命令行参数选择，启动后进入GDB交互界面，提示符为(gdb)，所有调试命令均在此界面执行。

方式1：直接启动，无命令行参数

gdb 可执行程序名
# 示例
gdb test

方式2：启动时指定命令行参数（适合需要传参的程序）

gdb –args 可执行程序名 参数1 参数2 ...
# 示例：test需要传参10 20
gdb –args test 10 20

方式3：先启动GDB，再设置命令行参数

# 1. 启动GDB
gdb test
# 2. GDB界面中设置参数
(gdb) set args 10 20

3.3 GDB核心调试命令（必记）

GDB调试命令支持缩写（如list→l，break→b），大幅减少输入，以下为开发高频使用的核心命令，按调试流程排序，覆盖从断点设置到程序退出的全流程。

1. 查看源代码：list/l

查看源码，关联调试信息，支持指定行号、函数名、文件名，方便定位调试位置：

(gdb) l # 下翻源码，每次显示10行
(gdb) l – # 上翻源码
(gdb) l 20 # 查看第20行附近的源码
(gdb) l main # 查看main函数附近的源码
(gdb) l foo.c:20 # 查看foo.c文件第20行源码
(gdb) l foo.c:add # 查看foo.c文件add函数源码

2. 设置断点：break/b

断点是调试的核心，程序运行到断点处会暂停，方便查看变量、执行流程，支持指定行号、函数名、文件名：

(gdb) b 20 # 在当前文件第20行设置断点
(gdb) b main # 在main函数开头设置断点
(gdb) b foo.c:20 # 在foo.c文件第20行设置断点
(gdb) b foo.c:add # 在foo.c文件add函数开头设置断点

3. 查看断点：info break/i b

查看已设置的所有断点信息，包含断点编号、是否有效、断点位置，断点编号是删除/忽略断点的依据：

(gdb) info break
# 输出示例
Num Type Disp Enb Address What
1 breakpoint keep y 0x0000555555554e1d in main at test.c:7
2 breakpoint keep y 0x0000555555554e3d in add at test.c:15

字段说明：Num（断点编号）、Enb（是否有效，y=有效，n=无效）、What（断点位置）。

4. 删除断点：delete/d

删除指定编号的断点，或删除所有断点，调试完成后可清理断点：

(gdb) d 2 # 删除2号断点（指定编号）
(gdb) d # 删除所有断点

5. 启动/重启程序：run/r

启动调试的程序，程序会运行到第一个断点处暂停，若未设置断点则直接运行结束：

(gdb) r # 启动程序，断点处暂停

6. 继续执行：continue/c

程序在断点处暂停后，执行c命令，程序会继续运行到下一个断点处暂停，适合多断点调试：

(gdb) c # 继续运行到下一个断点

7. 忽略断点：ignore

调试循环代码时，可忽略断点指定次数，避免重复暂停，提升调试效率：

# 格式：ignore 断点编号 忽略次数
(gdb) ignore 1 10 # 忽略1号断点10次，第11次触发

8. 单步调试：step/s

进入函数的单步执行，每次执行一行代码，若遇到函数调用，则进入函数内部继续单步执行，适合调试函数内部逻辑：

(gdb) s # 单步执行，进入函数

9. 逐过程执行：next/n

不进入函数的单步执行，每次执行一行代码，若遇到函数调用，将函数调用视为一条语句直接执行，适合跳过无关函数，调试主流程：

(gdb) n # 逐过程执行，不进入函数

10. 跳出函数：finish

在函数内部单步调试时，执行finish命令，会执行完整个函数并返回到函数调用处，适合快速退出函数：

(gdb) finish # 执行完当前函数，返回调用处

11. 变量监视与修改：print/p

打印变量/表达式的值，还可直接修改变量的值，无需重新编译，方便测试不同变量值的程序行为：

(gdb) p i # 打印变量i的值
(gdb) p a+b # 打印表达式a+b的值
(gdb) p i=100 # 修改变量i的值为100，继续调试

12. 自动监视变量：display/undisplay

print仅打印一次，display可自动打印变量/表达式的值，程序每次暂停时都会显示，适合持续关注某个变量的变化；undisplay用于取消自动监视：

(gdb) display i # 自动打印i的值
(gdb) display a*b # 自动打印表达式a*b的值
(gdb) info display # 查看所有自动监视的信息（含编号）
(gdb) undisplay 2 # 取消2号自动监视
(gdb) undisplay # 取消所有自动监视

13. 查看参数/局部变量：info args/info locals

快速查看当前函数的参数和所有局部变量的值，无需逐个打印，提升调试效率：

(gdb) info args # 查看当前函数的参数名和值
(gdb) info locals # 查看当前函数的所有局部变量名和值

14. 查看栈帧：bt/frame

程序崩溃时，通过栈帧可查看函数的调用链（哪个函数调用了当前函数，层层追溯），是排查崩溃问题的核心命令；frame可切换到指定栈帧：

(gdb) bt # 查看所有栈帧，显示函数调用链
(gdb) frame 3 # 切换到3号栈帧，查看对应函数的信息

15. 退出GDB：quit/q

调试完成后，退出GDB交互界面，返回Linux终端：

(gdb) q # 退出GDB

3.4 高级调试：Core Dump文件调试

程序异常崩溃时（如段错误、除零错误），Linux会生成Core Dump文件（核心转储文件），该文件保存了程序崩溃瞬间的寄存器状态、栈帧、变量值等信息，类似“飞机黑匣子”，通过GDB分析Core Dump文件，可快速定位崩溃原因。

步骤1：开启系统Core Dump功能

Linux默认关闭Core Dump（核心文件大小设为0），需先开启，设置核心文件大小无限制：

# 查看当前Core Dump设置，core file size为0表示关闭
ulimit -a
# 临时开启：设置核心文件大小无限制（重启终端失效）
ulimit -c unlimited

步骤2：配置Core Dump文件格式

修改系统配置，指定Core Dump文件的命名格式（包含程序名、信号、时间），方便识别：

# 编辑系统配置文件
sudo vim /etc/sysctl.conf
# 添加以下内容，保存退出
kernel.core_pattern = %e_core_%s_%t
# %e：程序名，%s：崩溃信号，%t：时间戳
# 使配置生效
sudo sysctl -p

步骤3：生成Core Dump文件

运行带调试信息的可执行程序，使其异常崩溃，系统会自动在当前目录生成Core Dump文件：

# 运行程序，触发崩溃（如除零错误、段错误）
./test
# 生成的文件示例：test_core_8_1679196427

步骤4：GDB分析Core Dump文件

通过GDB加载可执行程序和Core Dump文件，直接定位崩溃位置和调用链：

# 格式：gdb 可执行程序名 Core Dump文件名
gdb test test_core_8_1679196427

GDB会直接显示崩溃位置（行号、代码），然后通过bt查看函数调用链，info args/locals查看变量值，快速定位崩溃原因。

四、静态库与动态库：代码复用的核心

库是可复用的二进制代码集合，由多个目标文件打包而成，开发中无需重复编写基础代码（如算法、工具函数），直接引用库即可，大幅提升开发效率。Linux下库分为静态库和动态库，两者的链接方式和使用特性截然不同。

4.1 库的基本概念

• 静态库：Linux下后缀为.a，Windows下为.lib，链接阶段直接打包到可执行程序中。
• 动态库：Linux下后缀为.so，Windows下为.dll，链接阶段不打包，程序运行时动态加载。
• 库的命名规范：lib+库名+后缀（如libalgs.a、libalgs.so，库名为algs）。
• 链接库：编译时通过-l库名链接（如-lalgs，自动匹配libalgs.a/libalgs.so）。

4.2 静态库VS动态库（核心区别）

两者的核心差异在于链接阶段和运行阶段的处理，决定了其适用场景，对比如下：

4.3 创建与使用静态库（.a）

以自定义算法库algs（包含加、减、乘、除函数）为例，讲解静态库的创建和使用全流程。

步骤1：编写库的源码和头文件

// 头文件：algs.h（函数声明）
#ifndef __WD_ALGS_H
#define __WD_ALGS_H
int add(int a, int b);
int sub(int a, int b);
int mul(int a, int b);
int div(int a, int b);
#endif

// 源文件：add.c
#include "algs.h"
int add(int a, int b) { return a + b; }
// 源文件：sub.c
#include "algs.h"
int sub(int a, int b) { return a – b; }
// 源文件：mul.c
#include "algs.h"
int mul(int a, int b) { return a * b; }
// 源文件：div.c
#include "algs.h"
int div(int a, int b) { return a / b; }

步骤2：编译生成目标文件（.o）

gcc -c add.c sub.c mul.c div.c
# 生成add.o、sub.o、mul.o、div.o

步骤3：用ar命令打包为静态库（.a）

ar是Linux下的库打包工具，crsv为固定选项，用于创建、替换、显示打包信息：

# 格式：ar crsv 静态库名 目标文件1 目标文件2 …
ar crsv libalgs.a add.o sub.o mul.o div.o
# 生成静态库libalgs.a

步骤4：将静态库放入系统库目录

Linux默认搜索/usr/lib、/lib等目录中的库文件，将静态库移动到/usr/lib，方便编译器查找：

sudo mv libalgs.a /usr/lib

步骤5：编写程序，链接并使用静态库

// main.c：引用静态库的函数
#include <stdio.h>
#include "algs.h" // 包含库的头文件
int main() {
printf("add(7,3)=%d\\n", add(7,3));
printf("mul(7,3)=%d\\n", mul(7,3));
return 0;
}

编译时通过-lalgs链接静态库（自动匹配libalgs.a）：

gcc main.c -o main -lalgs
# 运行程序
./main

关键特性验证

删除静态库后，程序仍可正常运行（静态库已打包到可执行程序中）：

sudo rm /usr/lib/libalgs.a
./main # 正常输出，无报错

4.4 创建与使用动态库（.so）

同样以algs库为例，动态库的创建比静态库多一个-fpic选项（位置无关代码），链接时用-shared选项。

步骤1：编写库的源码和头文件（同静态库，略）

步骤2：编译生成位置无关的目标文件（.o）

添加-fpic选项，生成位置无关代码（动态库必须的，保证库可在任意内存地址加载）：

gcc -c add.c sub.c mul.c div.c -fpic
# 生成位置无关的目标文件

步骤3：编译打包为动态库（.so）

用gcc -shared选项将目标文件打包为动态库：

# 格式：gcc -shared 目标文件… -o 动态库名
gcc -shared add.o sub.o mul.o div.o -o libalgs.so
# 生成动态库libalgs.so

步骤4：将动态库放入系统库目录

sudo mv libalgs.so /usr/lib

步骤5：编写程序，链接并使用动态库

源码同静态库的main.c，编译命令也相同（-lalgs自动匹配libalgs.so）：

gcc main.c -o main -lalgs
# 运行程序
./main

关键特性验证

删除动态库后，程序无法运行（运行时依赖动态库）：

sudo rm /usr/lib/libalgs.so
./main # 报错：找不到libalgs.so

4.5 动态库的更新（核心优势）

动态库的核心优势是更新方便，无需重新编译引用的程序，仅需更新动态库文件，并用符号链接指向新库，方便回退旧版本。

示例：更新algs库，添加打印功能

五、Makefile：Linux项目的自动化构建工具

Linux下的大型项目包含数十个甚至数百个源文件，手动用gcc编译会极其繁琐（需指定依赖、编译顺序），Makefile通过定义编译规则，实现项目的自动化编译和增量编译，只需一个make命令，即可完成整个项目的构建，是Linux开发中管理项目的核心工具。

5.1 Makefile的核心优势

5.2 Makefile的核心规则

Makefile的核心是规则，一个规则定义了目标文件、依赖文件和编译命令，Make工具通过解析规则，自动完成编译。

规则的基本格式

target: prerequisites
commands
# target：目标文件（可执行程序、.o文件、伪目标如clean）
# prerequisites：生成目标的依赖文件（.c、.h、.o等）
# commands：生成目标的命令（shell命令，如gcc，必须以Tab开头！）

规则的执行逻辑

5.3 一个简单的Makefile示例

以algs库+main.c的多文件项目为例，编写基础Makefile，实现自动化编译：

# 目标：可执行程序main，依赖4个.o文件
main: main.o add.o sub.o mul.o div.o
gcc main.o add.o sub.o mul.o div.o -o main # Tab开头
# 目标：main.o，依赖main.c和algs.h
main.o: main.c algs.h
gcc -c main.c -Wall -g # Tab开头
# 目标：add.o，依赖add.c和algs.h
add.o: add.c algs.h
gcc -c add.c -Wall -g
# 目标：sub.o，依赖sub.c和algs.h
sub.o: sub.c algs.h
gcc -c sub.c -Wall -g
# 目标：mul.o，依赖mul.c和algs.h
mul.o: mul.c algs.h
gcc -c mul.c -Wall -g
# 目标：div.o，依赖div.c和algs.h
div.o: div.c algs.h
gcc -c div.c -Wall -g

执行Makefile

在Makefile所在目录执行make命令，Make会自动解析规则，构建项目：

make
# 运行可执行程序
./main

增量编译验证

修改add.c后，重新执行make，仅重新编译add.c并链接，其他文件不编译：

# 修改add.c
vim add.c
# 重新make
make
# 输出：仅编译add.c，然后链接
gcc -c add.c -Wall -g
gcc main.o add.o sub.o mul.o div.o -o main

5.4 伪目标：clean与rebuild

Makefile默认管理文件目标，若存在与目标同名的文件，会导致目标无法执行（如存在clean文件，make clean会失效）。伪目标通过.PHONY声明，与文件无关，强制执行命令，最常用的伪目标是clean（清理编译文件）和rebuild（重新构建）。

带伪目标的Makefile

# 基础编译规则（同前，略）
main: main.o add.o sub.o mul.o div.o
gcc $^ -o $@
main.o: main.c algs.h
gcc -c $< -Wall -g
add.o: add.c algs.h
gcc -c $< -Wall -g
sub.o: sub.c algs.h
gcc -c $< -Wall -g
mul.o: mul.c algs.h
gcc -c $< -Wall -g
div.o: div.c algs.h
gcc -c $< -Wall -g

# 声明伪目标，避免与文件冲突
.PHONY: clean rebuild
# 伪目标：clean，清理可执行程序和所有.o文件
clean:
rm -f main main.o add.o sub.o mul.o div.o
# 伪目标：rebuild，先clean再构建main（依赖clean和main）
rebuild: clean main

执行伪目标

# 清理编译文件
make clean
# 重新构建项目（先清理，再编译）
make rebuild

5.5 Makefile变量：简化规则编写

Makefile支持变量，类似C语言的宏，用于替代重复的字符串（如目标文件列表、编译器、编译选项），大幅简化Makefile编写，便于维护（修改变量即可全局生效）。

变量的基本用法

• 定义：变量名 := 变量值（推荐）或变量名 = 变量值
• 使用：$(变量名)或${变量名}
• 特性：大小写敏感，FOO和foo是不同变量。

三类常用变量

5.6 进阶Makefile：变量+模式规则+内置函数

通过自定义变量、预定义变量、自动变量、模式规则和内置函数，编写通用、可扩展的Makefile，适配任意多文件项目，无需逐个定义.o文件的规则。

核心进阶特性

通用Makefile模板（必记，可直接复用）

# 1. 自定义变量：适配任意项目，仅需修改此处
Out := main # 可执行程序名
CC := gcc # 编译器
CFLAGS := -Wall -g # 编译选项

# 2. 内置函数：自动查找所有.c文件，转换为.o文件
Srcs := $(wildcard *.c) # 查找当前目录所有.c文件，赋值给Srcs
Objs := $(patsubst %.c, %.o, $(Srcs)) # 将.c替换为.o，得到所有目标文件

# 3. 主规则：可执行程序依赖所有.o文件
$(Out): $(Objs)
$(CC) $^ -o $@ # $^：所有依赖，$@：目标

# 4. 模式规则：所有.o文件依赖对应的.c文件和头文件（通用规则，无需逐个定义）
%.o: %.c algs.h
$(CC) -c $< $(CFLAGS) # $<：第一个依赖文件（即%.c）

# 5. 伪目标：清理和重新构建
.PHONY: clean rebuild
clean:
$(RM) $(Out) $(Objs) # $(RM)：预定义变量，等价于rm -f
rebuild: clean $(Out)

模板优势

六、总结

本文覆盖了Linux GCC编译工具链的四大核心模块，从基础的GCC编译到高级的Makefile自动化构建，形成了Linux C/C++开发的完整工具链体系，核心要点总结如下：

GCC编译工具链是Linux开发的基础，掌握后可轻松应对Linux下的C/C++项目开发、开源项目编译和自定义工具开发，为后续的Linux高级开发（如网络编程、驱动开发）打下坚实的基础。

标签：Linux GCC、GDB调试、静态库动态库、Makefile、Linux C开发、编译工具链
声明：本文基于GNU GCC工具链，适用于Ubuntu/Debian系列Linux，RedHat/CentOS系列仅包管理器（yum/dnf）不同，核心命令和规则完全通用。