大家好，我是程序员 - 阿布拉。一名干了9年Unity的开发者... 热爱游戏，喜欢讲课。很感谢你关注到了【Unity游戏开发之路】这个网站。❤️

1. 预处理阶段（Preprocessing）

为什么需要预处理？

预处理器解决了三个核心问题：

代码模块化：通过 #include 机制实现代码分离和重用，避免重复编写。

条件编译：通过 #ifdef 等指令适配不同平台和配置：

#ifdef _WIN32
    #include <windows.h>
    #define PATH_SEPARATOR "\\"
#else
    #include <unistd.h>
    #define PATH_SEPARATOR "/"
#endif

编译时计算：宏在编译时展开，无运行时开销：

#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))

预处理器的工作流程

# 查看预处理结果
gcc -E source.c -o source.i
clang -E -dM source.c  # 显示所有预定义宏

预处理后，原始的几十行代码可能展开为几千行（包含所有头文件内容）。

2. 编译阶段（Compilation）

基础步骤（C和C++共同）

词法分析：将源码分解为标记（tokens）
语法分析：构建抽象语法树（AST）
语义分析：类型检查、作用域解析

C++特有的编译处理

模板处理

模板是C++的核心特性，编译器需要复杂的处理：

// 函数模板
template<typename T>
T max(T a, T b) {
    return a > b ? a : b;
}

// 类模板
template<typename T, size_t N>
class Array {
    T data[N];
public:
    constexpr size_t size() const { return N; }
    T& operator[](size_t i) { return data[i]; }
};

// 完整特化
template<>
class Array<bool, 8> {
    unsigned char bits;  // 特殊优化：8个bool用1字节
public:
    // ...
};

// 偏特化
template<typename T>
class Array<T*, 10> {  // 指针类型的特殊处理
    // ...
};

// 变参模板（C++11）
template<typename... Args>
void print(Args... args) {
    ((std::cout << args << " "), ...);  // C++17折叠表达式
}

编译器的模板实例化策略：

延迟实例化：只在使用时生成代码
显式实例化：强制生成特定版本
外部模板：避免重复实例化（C++11）

// 显式实例化
template class Array<int, 100>;  // 强制实例化

// 外部模板声明（防止自动实例化）
extern template class Array<double, 50>;

函数重载与名称修饰

// 重载解析的复杂性
void func(int);          // #1
void func(double);       // #2
void func(int, int = 0); // #3

template<typename T>
void func(T);            // #4

func(42);      // 调用 #1（精确匹配优于模板）
func(3.14);    // 调用 #2
func(42, 1);   // 调用 #3
func("hello"); // 调用 #4（模板推导）

名称修饰规则：

namespace std {
    template<typename T>
    class vector {
        void push_back(const T&);
    };
}

// Itanium ABI (Linux/macOS)
// _ZNSt6vectorIiE9push_backERKi
// 解码：std::vector<int>::push_back(int const&)

// MSVC (Windows)
// ?push_back@?$vector@H@std@@QAEXABH@Z

RAII与异常安全

编译器自动生成异常安全代码：

void risky_function() {
    Resource r1("first");   // 构造函数
    Resource r2("second");  // 构造函数
    
    if (error_condition) {
        throw std::runtime_error("error");
        // 编译器保证：r2析构 → r1析构
    }
    
    // 正常退出：r2析构 → r1析构
}

// 编译器生成的异常表（概念）
// try_begin:
//   construct r1
//   register_cleanup(r1.destructor)
//   construct r2
//   register_cleanup(r2.destructor)
//   ...
// exception_handler:
//   unwind_stack()
//   call_registered_cleanups()

3. 汇编阶段（Assembly）

将编译器生成的汇编代码转换为机器码：

# 生成汇编代码
gcc -S source.c -o source.s
# 汇编为目标文件
gcc -c source.s -o source.o

目标文件包含：

代码段（.text）：机器指令
数据段（.data）：已初始化全局变量
BSS段（.bss）：未初始化全局变量
符号表：函数和变量信息
重定位表：需要链接器修正的引用

4. 链接阶段（Linking）

链接器将多个目标文件组合成可执行文件。

链接解决了软件工程的三个核心问题：

模块化编程：支持分离编译、并行开发、增量构建
内存优化：代码段共享、统一地址空间布局
功能复用：标准库、第三方库、系统调用封装

静态链接 vs 动态链接

静态链接

将所有代码和数据复制到最终可执行文件：

# 创建静态库
ar rcs libutil.a util1.o util2.o

# 静态链接
gcc main.o libutil.a -o app

# 结果：app包含所有代码，可独立运行

内存布局（静态链接）：

可执行文件：
┌─────────────────┐
│   ELF Header    │
├─────────────────┤
│   .text         │ ← main.o代码
│                 │ ← libutil.a代码（完整复制）
│                 │ ← libc.a部分代码（按需复制）
├─────────────────┤
│   .data         │ ← 所有初始化数据
├─────────────────┤
│   .bss          │ ← 所有未初始化数据
└─────────────────┘

动态链接

仅记录依赖关系，运行时加载

# 创建动态库
gcc -shared -fPIC util1.o util2.o -o libutil.so

# 动态链接
gcc main.o -L. -lutil -o app

# 运行时需要设置库路径
export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
./app

运行时内存布局（动态链接）

进程地址空间：
┌─────────────────┐ 0xFFFFFFFF
│   内核空间       │
├─────────────────┤
│   栈            │ ↓
├─────────────────┤
│   mmap区域      │ ← libutil.so映射
│                 │ ← libc.so映射
├─────────────────┤
│   堆            │ ↑
├─────────────────┤
│   .bss/.data    │
├─────────────────┤
│   .text         │ ← 仅主程序代码
└─────────────────┘ 0x400000

性能差异原理

静态链接：直接调用

call 0x401234  # 直接跳转

动态链接：通过PLT/GOT间接调用

call printf@plt    # → PLT存根
# PLT:
jmp *printf@got    # → GOT表项
# 首次调用时解析，后续直接跳转

链接优化技术

LTO（Link Time Optimization）

# 启用LTO
gcc -flto -O3 file1.c file2.c -o app

# 跨文件优化：内联、去虚化、死代码消除

符号版本控制

// version.map
LIBFOO_1.0 {
    global: foo_init; foo_process;
    local: *;
};

LIBFOO_2.0 {
    global: foo_process_v2;
} LIBFOO_1.0;

// 编译：gcc -Wl,--version-script=version.map