1 C 程序构建与运行流程
C 程序的构建与运行流程如下图所示：
上图展示了 C 语言程序从源代码到可执行文件的完整流程。下面将逐步讲解每个阶段的核心任务及对应生成的中间文件。
1.1 编写源代码
C 程序开发的第一步是编写源代码文件。源代码是用 C 语言语法编写的纯文本文件，文件扩展名通常为 .c。
虽然 C 标准并未强制规定文件扩展名，但业界普遍约定使用 .c，以便编译器或构建系统自动识别源文件。
源文件可以使用任意文本编辑器编写，例如 VS Code、Notepad++、CLion 等。
示例：在 VS Code 中创建一个名为 main.c 的文件，内容如下：
#include
int main(void) // 主函数，不接收参数
{
printf("Hello, World"); // 输出字符串到控制台
return 0; // 程序正常退出
}
1.2 预处理
预处理（Preprocessing）是 C 程序编译流程的第一个阶段。
在这一阶段，源文件（例如 main.c）会交由预处理器（Preprocessor）进行文本级处理，对代码进行整理与转换，为后续编译阶段做好准备。
预处理阶段的主要工作包括：
移除注释与规范化空白：
删除所有注释（包括 // 单行注释与 /* ... */ 多行注释）。对空格、制表符、换行符等空白字符进行规范化处理。
处理预处理指令（以 # 开头）：
头文件包含（#include）：将指定头文件的内容直接插入到该指令所在位置。宏定义与替换（#define）：定义符号常量或宏函数，并在源代码中进行文本替换。条件编译（#ifdef、#ifndef、#endif 等）：根据条件选择性地编译或忽略部分代码。
生成预处理结果文件：
经过预处理后的代码通常保存为扩展名为 .i 的中间文件。该文件包含所有宏展开与头文件展开后的纯 C 代码，可直接进入后续的语法分析与编译阶段。
1.3 编译
编译（Compilation）阶段的任务是将经过预处理的 .i 文件转换为特定目标架构的汇编代码。
这一过程由编译器（Compiler）完成，属于 “语义级” 处理，与预处理阶段的 “文本级” 处理相区别。
编译阶段的主要工作包括：
词法分析、语法分析与语义分析：
词法分析：将源代码拆分为最小的语法单元（Token），如关键字、标识符、运算符、常量等。语法分析：根据 C 语言语法规则，将 Token 结构化为抽象语法树（Abstract Syntax Tree，AST），并检测语法错误。语义分析：检查变量作用域、类型匹配、表达式合法性等语义约束，确保程序逻辑正确无歧义。
中间表示与优化：
编译器将语法树转换为中间表示（Intermediate Representation，IR），这是一种介于源代码与目标代码之间的抽象形式。基于 IR，编译器会执行多种优化操作，例如：
常量传播：在编译阶段提前计算可确定的常量值。死代码消除：移除永远不会被执行的语句或分支。循环优化：包括循环展开、循环不变代码外提等，以提升执行效率。
代码生成：编译器将优化后的中间表示转换为目标平台的汇编指令。输出汇编文件：生成的汇编文件扩展名因工具链而异：
在 GCC、Clang 及 MinGW 等环境中：通常使用 .s 作为扩展名。在 Microsoft Visual Studio 环境中：一般使用 .asm 作为扩展名。
1.4 汇编
汇编（Assembly）阶段的任务是将由编译阶段生成的汇编语言代码（.s 或 .asm 文件）转换为可重定位的二进制机器指令。
这一过程由汇编器（Assembler）完成，是编译流程中从 “可读文本指令” 到 “机器可执行代码片段” 的关键过渡。
汇编阶段的主要工作包括：
读取与解析汇编代码：汇编器加载编译阶段生成的汇编源文件，解析其中的指令、伪指令、数据定义与符号声明。指令翻译与数据生成：
将每条汇编指令的助记符（如 mov、call、jmp 等）转换为对应处理器架构的机器指令编码。构建程序的各个段（Section），如 .text（代码段）、.data（已初始化数据段）、.bss（未初始化数据段）等。生成符号表（Symbol Table），记录全局变量、函数入口点等符号及其在目标文件中的相对位置。
生成目标文件：汇编器最终输出一个目标文件，作为后续链接阶段的输入。其扩展名依工具链而异：
在 GCC、Clang 及 MinGW 等环境中：通常使用 .o 作为扩展名。在 Microsoft Visual Studio 环境中：一般使用 .obj 作为扩展名。
生成的目标文件是一种中间二进制产物，其内容包括：机器指令与已初始化数据、符号表、重定位信息、调试信息，由于尚未经过链接阶段，函数与全局变量的实际内存地址尚未被最终确定，因此目标文件本身尚不可独立执行。
1.5 链接
链接（Linking）是 C 程序构建流程的最后一个阶段。
在此阶段，链接器（Linker）将一个或多个可重定位目标文件与所需库文件进行整合，解析符号引用并完成地址重定位，最终生成可执行文件或可复用的库模块。
链接阶段的主要工作包括：
读取输入文件：
链接器首先加载所有需要参与链接的目标文件（.o 或 .obj），并根据编译器选项或链接指令确定加载顺序。在静态链接中，输入文件顺序尤为重要，因为符号解析通常遵循 “先定义、后引用” 的规则。
加载库文件：根据程序的依赖关系，链接器会同时加载相应的库文件，分为两类：
静态库
类 Unix 系统使用 .a 文件。Windows 系统使用 .lib 文件。静态库在链接时被整合，其内容会被复制并嵌入到最终的可执行文件中，因此生成的程序在运行时无需依赖外部库文件。
动态共享库
类 Unix 系统使用 .so 文件。Windows 系统使用 .dll 文件。动态库在链接时仅记录引用信息，并不会将库内容复制到可执行文件中。程序在运行时（Run time）由操作系统动态加载这些库，从而减小可执行文件体积，并支持库文件的独立更新与共享使用。
符号解析与地址重定位：
符号解析：链接器扫描所有目标文件与库文件，解析每个符号引用（例如对 printf 的调用），确保每个外部符号都有唯一、合法的定义。地址绑定与重定位：
链接器为各个程序段分配最终的内存地址，包括：代码段（.text）、已初始化数据段（.data）、未初始化数据段（.bss）。随后修正目标文件中的相对地址或占位符，使所有函数调用与数据访问都能指向正确的绝对地址。
生成可执行文件：链接完成后，生成符合目标平台二进制格式的最终文件：
类 Unix 系统（Linux、macOS）：默认输出文件名为 a.out，可通过 -o 选项自定义名称。Windows 系统：默认输出文件名为 a.exe，同样可使用 -o 指定输出文件名。
1.6 运行
运行（Execution）是将链接生成的可执行文件由操作系统加载到内存中并开始执行指令的过程。
它是整个程序构建流程的最后环节，用于验证程序逻辑与功能是否按预期实现。
运行阶段的主要工作包括：
加载与初始化：
操作系统读取可执行文件，根据其文件格式（如 ELF、PE、Mach-O 等），将各个段加载到内存的指定区域：
代码段（.text）：存放可执行指令。已初始化数据段（.data）：存放已初始化的全局与静态变量。未初始化数据段（.bss）：存放未初始化的全局与静态变量。
随后执行必要的地址重定位，并完成运行环境初始化，包括：
设置程序的堆栈（Stack）与堆区（Heap）。初始化静态与全局变量。建立命令行参数（argc、argv）与环境变量表。
程序执行：
程序从入口点开始执行（通常是 _start），然后由启动代码调用 main() 函数。执行过程中，CPU 按顺序执行机器指令，完成输入处理、逻辑计算、内存访问与输出操作。当程序结束时，通过 return 或 exit() 将控制权返回给操作系统；若发生异常，则触发异常退出。
结果验证与调试：
在命令行中启动程序以验证运行结果：
在 Linux/macOS 终端中：使用 ./程序名，例如 ./main 或 ./a.out。在 Windows 的 CMD 或 PowerShell 中：使用 程序名.exe 或 .\程序名.exe，例如 main.exe 或 .\a.exe。
程序的输出结果（如控制台打印、文件写入或返回值）用于验证功能与逻辑是否正确。若结果不符合预期，可借助调试工具（如 GDB）进行断点调试、变量检查与堆栈回溯，定位问题后修改源代码，再重新编译、链接与运行。
1.7 流程概览
C 语言程序在运行前会经历一系列翻译与处理阶段。整个流程可分为六步：编写源代码、预处理、编译、汇编、链接，最后在操作系统中运行。下表总结了每个阶段的阶段产物、使用的核心程序及其主要职责，便于快速理解整个过程。
阶段阶段产物核心程序主要职责1. 编写源代码main.c
编辑器
（Editor）
编写并保存 C 语言源文件，使用标准扩展名 .c。2. 预处理main.i
预处理器
（Preprocessor）
移除注释与规范化空白；处理预处理指令（如 #include、#define、#ifdef 等）；展开头文件与宏，生成纯净的 C 代码。3. 编译main.s 或 main.asm
编译器
（Compiler）
执行词法、语法与语义分析；生成中间表示（IR）并进行优化；将 C 源码转换为目标架构的汇编代码。4. 汇编main.o 或 main.obj
汇编器
（Assembler）
将汇编代码翻译为机器指令；生成可重定位的目标文件，包含符号表与重定位信息。5. 链接main.exe 或 a.exe
main 或 a.out
链接器
（Linker）
将一个或多个目标文件与库文件合并；解析符号引用；分配最终内存地址；生成可执行文件。6. 运行-
操作系统
（OS）
加载可执行文件至内存；初始化运行环境（堆栈、数据段、全局变量）；执行程序并验证输出与行为。
💡 提示：学习建议
由于目前尚未学习到相关概念，例如：预处理指令、宏定义与替换、条件编译、全局变量、静态变量等，因此本节内容可暂时作为理解性阅读。当你后续系统学习完这些知识点，或对 C 语言整体结构有更深入认识后，建议重新回顾此篇。
这部分内容在实际开发与技术面试中都极其重要，面试官常常通过 “C 程序的构建与运行流程” 来考察候选人对编译体系与底层机制的理解深度。
2 GCC 分步构建 C 程序演示
在通常的 IDE 或常规编译命令中，GCC 等编译器会自动完成预处理、编译、汇编和链接等所有步骤，直接生成最终可执行文件，中间文件通常不会保留。
为了深入理解 C 程序的构建流程，本小节将使用命令行工具（如 VS Code 集成终端）手动分步执行每个阶段。通过保留并查看生成的中间文件（如 .i、.s、.o），可以直观地展示源代码到可执行文件的完整转换过程。
2.1 打开 VS Code 集成终端
你可以通过以下任一方式打开 VS Code 集成终端：
1. 通过顶部菜单：选择 “...” -> “终端” -> “新建终端” ，具体操作如下所示：
2. 通过右键菜单：在 VS Code 资源管理器中右键点击，选择 “在集成终端中打开”，具体操作如下所示：
2.2 预处理：生成 .i 文件（gcc -E）
在终端中执行以下命令，可对 C 源代码文件 main.c 进行预处理，并将结果输出到 main.i 文件：
gcc -E main.c -o main.i
参数说明：
gcc：调用 GCC 编译器。-E：只执行预处理，完成后停止编译流程。main.c：指定输入的源文件。-o main.i：指定输出文件为 main.i。
命令执行成功后，将生成 main.i 文件。该文件包含源代码和通过 #include 插入的头文件内容，形成预处理后的完整 C 代码，如下图所示：
打开生成的 main.i 文件可以看到，原始代码中通过 #include 引入的头文件（stdio.h）已被展开并直接插入到文件中，因此预处理后的文件体积通常比源代码大很多。
如果省略 -o main.i 选项，GCC 默认会将预处理结果直接输出到终端屏幕，而不会保存为文件。如下图所示：
2.3 编译：生成 .s 文件（gcc -S）
GCC 可以通过以下两种方式生成汇编代码文件 .s：
1. 从 C 源文件直接生成（推荐）
gcc -S main.c -o main.s
此命令会自动完成预处理和编译阶段，直接生成汇编代码文件。
2. 从预处理文件生成
gcc -S main.i -o main.s
此命令基于已生成的 .i 文件进行编译，仅生成汇编代码。
参数说明：
gcc：调用 GCC 编译器。-S：生成汇编代码后停止编译。main.c / main.i：指定输入文件。-o main.s：指定输出汇编文件名。
命令执行成功后，将生成 main.s 文件，其中包含对应目标平台的汇编指令，如下图所示：
如果省略 -o main.s 选项，GCC 将根据输入文件的名称（如 main）自动生成输出文件。例如：
当输入文件为 main.c 时，默认生成 main.s。当输入文件为 main.i 时，同样默认生成 main.s。
💡 提示：扩展名说明
GCC 编译器使用 -S 选项生成汇编代码时，无论在 Windows、Linux 或 macOS 平台，默认输出文件扩展名都是 .s，而非 .asm，这是 GCC 工具链的统一标准行为。
2.4 汇编：生成 .o 文件（gcc -c）
GCC 可以通过以下三种方式生成目标文件 .o，不同方式对应的起始阶段略有不同：
1. 从 C 源文件直接生成（推荐）
gcc -c main.c -o main.o
此命令会自动完成预处理、编译和汇编三个阶段，直接生成目标文件。
2. 从预处理文件生成
gcc -c main.i -o main.o
此命令基于已生成的 .i 文件进行编译和汇编，生成目标文件。
3. 从汇编文件生成
gcc -c main.s -o main.o
此命令直接将汇编代码文件（.s）汇编为目标文件。
参数说明：
gcc：调用 GCC 编译器。-c：生成目标文件后停止，不进行链接。main.c / main.i / main.s：指定输入文件。-o main.o：指定输出目标文件名。
⚠️ 注意：编译起点的影响
虽然这三种方式最终生成的目标文件内容相同，但从更早阶段的文件（如 .c 源文件）开始生成，可以确保所有中间步骤基于最新源代码重新处理，从而避免依赖过时文件，提高构建的可靠性和一致性。
命令执行成功后，将生成 main.o 目标文件，其中包含机器指令和符号信息，但尚未进行最终链接，如下图所示：
如果省略 -o main.o 选项，GCC 将根据输入文件的名称（如 main）自动生成输出文件。例如：
当输入文件为 main.c 时，默认生成 main.o。当输入文件为 main.i 时，同样默认生成 main.o。当输入文件为 main.s 时，同样默认生成 main.o。
💡 提示：扩展名说明
GCC 编译器在使用 -c 选项生成目标文件时，所有主流操作系统（Windows、Linux、macOS）默认扩展名为 .o，这是 GCC 工具链统一规定，与操作系统无关。
如需生成 Windows 平台的 .obj 文件，需要使用 Windows 原生工具链，例如 MASM 汇编器或 MSVC（Microsoft Visual C++）编译器。
2.5 链接：生成可执行文件（gcc）
GCC 可以通过以下四种方式生成可执行文件，处理起点不同，但最终输出相同：
1. 从 C 源文件直接生成（推荐）
gcc main.c -o main
此命令会自动完成预处理、编译、汇编和链接全部四个阶段，直接生成可执行文件。
2. 从预处理文件生成
gcc main.i -o main
此命令基于已预处理的文件（.i）进行编译、汇编和链接，生成可执行文件。
3. 从汇编文件生成
gcc main.s -o main
此命令基于汇编代码文件（.s）进行汇编和链接，生成可执行文件。
4. 从目标文件生成
gcc main.o -o main
此命令将已汇编的目标文件（.o）进行链接，生成可执行文件。
参数说明：
gcc：调用 GCC 编译器。main.c / main.i / main.s / main.o：指定不同阶段的输入文件。-o main：指定输出可执行文件名。
命令执行成功后，将生成 main 可执行文件，其中包含完整的机器指令和运行时信息，可直接在操作系统中运行，如下图所示：
在上面的链接命令中，我们并未为输出文件指定扩展名（如 .exe）。实际上，这不会影响编译结果，这体现了 GCC 的设计巧妙之处。
使用 -o main 时，GCC 会将其视为基础文件名，并根据操作系统自动处理扩展名：
在 Linux / macOS 上生成无扩展名的 main。在 Windows 上则自动生成 main.exe。
这种设计保证了命令的跨平台一致性，同时简化了开发者操作，无需为不同平台修改构建指令。
如果省略 -o main 选项，GCC 将使用默认的可执行文件名：
在 Linux / macOS 等 Unix-like 系统中生成 a.out。在 Windows 系统中生成 a.exe。
这种方式适合快速测试，但在正式项目中建议始终使用 -o 明确指定输出文件名，以避免意外覆盖已有可执行文件。
2.6 运行可执行程序
在 VS Code 集成的 PowerShell 终端中，可以使用以下命令执行当前目录下的可执行文件：
./main.exe
或
.\main.exe
在 Windows PowerShell 中，这两种写法功能等效，都能正确执行当前目录（.\）下的可执行文件。差异主要源于操作系统和命令行解释器的路径表示习惯：
两种写法的区别：
./main.exe
起源：源于类 Unix 系统（如 Linux 和 macOS）中 Shell 的路径表示惯例。在 PowerShell 中的支持：虽非原生语法，但为方便用户跨平台使用和保持兼容性，PowerShell 也接受此种写法。
.\main.exe
起源：这是 PowerShell 自身原生的、标准的路径表示形式。语义：明确指示 “执行当前目录下名为 main.exe 的程序”。定位：PowerShell 设计中的标准用法，也是官方推荐的写法。
推荐写法：在 PowerShell 中建议始终使用 .\main.exe 的语法。这是符合其设计规范的标准做法，有助于避免与其他 Shell 的语法习惯相混淆。高效操作技巧：若觉得手动输入 .\ 较为繁琐，可在 PowerShell 中直接输入文件名（如 main），随后按下键盘上的 Tab 键，系统将自动将其补全为 .\main.exe，此方式能有效提升操作效率。如下图所示：
注意：在 PowerShell 中执行可执行程序时，如果程序未加入系统 PATH，则必须显式使用相对路径或绝对路径（例如 .\main.exe），因为 PowerShell 默认不会在当前目录搜索可执行文件，这是一种安全设计，防止意外运行当前目录下的未知程序。为了方便操作，可以输入文件名的一部分后按 Tab 键自动补全路径，兼顾安全性与效率。
相比之下，CMD（命令提示符）对当前目录下的可执行文件处理更宽松，即使未加入 PATH，也可以直接输入程序名执行。这简化了操作，但缺少对潜在安全风险的防护机制，如下图所示：
3 GCC 常用编译指令
GCC（GNU Compiler Collection）是 C 语言最常用且广泛应用的编译器套件之一。它提供丰富的编译选项，可精细控制程序从源代码到可执行文件的整个构建过程。
3.1 分步构建指令
GCC 可以将编译过程拆分为：“预处理 → 编译 → 汇编 → 链接” 四个阶段。分步构建有助于理解程序生成机制，也方便调试问题。
# 1. 预处理：对代码进行整理与转换，生成 .i 文件
gcc -E main.c -o main.i
# 2. 编译：将预处理后的代码编译成汇编代码，生成 .s 文件
gcc -S main.i -o main.s
# 3. 汇编：将汇编代码转换为目标文件（机器码），生成 .o 文件
gcc -c main.s -o main.o
# 4. 链接：将目标文件与库文件链接，生成最终的可执行程序
gcc main.o -o main
作用与用途：
理解编译流程：每个阶段生成的中间文件（.i、.s、.o）可以直观展示 C 程序从源代码到可执行文件的转换过程，加深对编译机制的理解。便于调试与问题定位：当程序编译或链接出现错误时，可以通过观察各阶段的中间文件，快速判断问题出现在哪个环节（例如预处理阶段头文件缺失，或链接阶段库文件未找到）。强化实践能力：熟悉分步构建命令有助于在实际开发中灵活控制编译流程，提高对编译器行为的掌握。
3.2 一站式编译与链接
在日常开发中，大多数场景无需分步构建，GCC 提供一条命令即可完成从预处理到链接的整个流程。
# 最基本用法，生成名为 a.out (Unix) 或 a.exe (Windows) 的可执行文件
gcc main.c
# 指定输出文件名，生成名为 'main' 或 'main.exe' 的可执行文件
gcc main.c -o main
# 编译多个源文件：同时编译并链接多个源文件
gcc file1.c file2.c main.c -o program
作用与用途：
快速开发：一条命令即可完成从源代码到可执行文件的全过程，适合绝大多数开发场景。指定输出文件名：使用 -o 选项避免覆盖默认生成的 a.out 或 a.exe，便于文件管理与版本控制。多文件编译：直接支持多个源文件的编译与链接，简化项目构建流程。
3.3 编译器诊断信息
GCC 提供了一系列命令，用于查看编译器信息、查询选项以及诊断构建问题，是排查编译错误和了解编译环境的必备工具。
# 查看 GCC 的版本信息
gcc --version
# 查看 GCC 的详细版本和构建配置信息
gcc -v
# 获取 GCC 支持的所有选项的简要说明
gcc --help
# 编译程序时启用详细模式，查看整个编译链接过程
gcc -v main.c -o main
作用与用途：
gcc --version：快速查看已安装的 GCC 版本，适合确认系统环境或判断是否需要升级。gcc -v：显示完整的 GCC 构建信息，包括版本、编译器构建参数、系统默认头文件和库的搜索路径，有助于调试复杂编译问题。gcc --help：列出 GCC 支持的所有选项及简要说明，方便查找命令参数用法或快速浏览可用功能。gcc -v main.c -o main：在实际编译过程中启用详细模式，会输出每一步构建信息，包括调用的汇编器和链接器、使用的编译参数以及搜索路径，是解决复杂编译错误或定位构建问题的 “终极诊断工具”。
3.4 警告与调试信息选项
在编写高质量、易维护的 C 程序时，合理使用 GCC 的警告选项和调试信息选项至关重要，可帮助开发者提前发现潜在问题，并方便调试。
# 开启常用警告提示，帮助发现潜在代码问题
gcc -Wall -Wextra main.c -o main
# 生成调试信息（供 GDB 调试器使用）
gcc -g main.c -o main
# 组合使用：开启所有警告并生成调试信息
gcc -Wall -Wextra -g main.c -o main
作用与用途：
-Wall 与 -Wextra：开启 GCC 的大部分警告信息。警告不会阻止程序生成，但会提示潜在错误、不规范写法或可移植性问题。建议在开发阶段尽量消除所有警告，以提高代码质量和可维护性。-g：在可执行文件中包含源代码信息、符号表和调试数据，是使用 GDB 或其他调试器进行源代码级调试的必要条件。发布版本通常去掉此选项，以减小可执行文件体积并避免泄露调试信息。组合使用 -Wall -Wextra -g：同时开启完整警告提示并生成调试信息，适用于开发和调试阶段，是保证代码安全性和可调试性的推荐配置。
3.5 代码优化选项
GCC 提供多种优化等级，可在编译速度、程序性能和调试便利性之间进行权衡。合理选择优化等级可生成更小或更快的程序，但可能牺牲调试便利性。
# 不优化（默认，编译速度最快，适合调试）
gcc -O0 -g main.c -o main
# 基础优化（减少代码大小和执行时间，但编译速度快）
gcc -O1 main.c -o main
# 中级优化（优化程度与编译速度平衡，推荐发布版本）
gcc -O2 main.c -o main
# 高级优化（启用所有优化方法，可能增加编译时间和代码大小）
gcc -O3 main.c -o main
# 优化代码大小（优先减小生成文件体积）
gcc -Os main.c -o main
作用与用途：
-O0（字母 O + 数字 0）：不进行任何优化，编译速度最快，生成的代码与源代码行一一对应。适合开发和调试阶段，可与 -g 搭配使用。-O1（字母 O + 数字 1）：启用基础优化，减少代码体积和执行时间，同时保持编译速度较快。适合调试完成后的轻量优化尝试。-O2（字母 O + 数字 2）：中级优化，启用比 -O1 更全面的优化策略，兼顾性能和编译速度。是发布版本的推荐选择。-O3（字母 O + 数字 3）：高级优化，在 -O2 基础上增加激进优化（如循环展开、更多内联函数等），可能增加编译时间和可执行文件大小。适用于追求极致性能的发布版本，但调试较困难。-Os（字母 O + 小写字母 s）：优化代码体积，优先减小可执行文件大小，同时执行所有不会显著增加代码体积的 -O2 优化。适合嵌入式或存储受限环境的发布版本。
3.6 指定 C 语言标准
GCC 默认可能使用较老或带 GNU 扩展的标准。为了保证代码可移植性并使用现代特性，可以通过 -std= 选项指定 ISO C 标准进行编译。
# 按最新 GNU 扩展标准编译（GCC 默认，包含部分非标准特性）
gcc main.c -o main
# 严格按照 C89/C90 标准编译（最早的 ANSI/ISO 标准）
gcc -std=c90 main.c -o main
# 严格按照 C99 标准编译（支持 // 注释、for 内变量声明等）
gcc -std=c99 main.c -o main
# 严格按照 C11 标准编译（支持多线程与泛型）
gcc -std=c11 main.c -o main
# 严格按照 C17 标准编译（C11 修订版，稳定可靠）
gcc -std=c17 main.c -o main
# 严格按照 C23 标准编译（最新标准，现代化特性）
gcc -std=c23 main.c -o main
# 使用带 GNU 扩展的 C11 标准（兼容 ISO 标准 + GCC 扩展）
gcc -std=gnu11 main.c -o main
作用与用途：
-std=c90：严格遵循最早的 ANSI/ISO 标准，适合维护旧项目或嵌入式平台，确保高度兼容性。-std=c99：支持单行注释 //、在 for 循环中声明变量、可变长数组等现代特性，适合对旧标准进行功能增强。-std=c11：引入泛型选择 _Generic、原子操作 _Atomic、多线程支持
使用建议：
新项目或学习 C 语言推荐使用 -std=c11 或 -std=c17，兼顾现代特性和稳定性。维护旧代码或嵌入式平台可选择 -std=c99 或 -std=c90。需要实验新特性或最新语法可尝试 -std=c23（需较新版本 GCC）。