返回专栏
· 18 分钟阅读

编译器与解释器


一、什么是编译器与解释器?

计算机的 CPU 最终执行的是机器指令,而开发者编写的源代码通常使用高级编程语言表达。

例如:

print("Hello World")

CPU 无法直接理解这段 Python 源代码,需要通过语言实现提供的编译、解释或其他执行机制,将程序转换为可执行的操作。

编译器和解释器就是完成这些工作的两类重要程序。

1.1 编译器(Compiler)

编译器是一种将源程序转换为另一种形式的程序。

常见转换目标包括:

  • 机器代码(Machine Code)。
  • 汇编代码(Assembly Code)。
  • 字节码(Bytecode)。
  • 中间表示(Intermediate Representation,IR)。
  • 其他高级语言代码。

编译器通常先分析源代码,再将其转换为目标代码。

例如,C 语言程序通常需要经过编译和链接,生成可执行文件。

flowchart TB
    A["C 源代码"] --> B["词法分析"]
    B --> C["语法分析"]
    C --> D["语义分析"]
    D --> E["中间表示 IR"]
    E --> F["代码优化"]
    F --> G["生成目标代码"]
    G --> H["链接"]
    H --> I["可执行文件"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style D fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style E fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style F fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

编译器的核心职责是分析程序并生成目标表示,但不一定负责最终执行程序。

1.2 解释器(Interpreter)

解释器是一种负责执行程序的运行时程序。

它读取程序代码或某种中间表示,根据语言定义的语义执行相应操作。

例如,解释器可以:

  • 读取源代码或字节码。
  • 执行指令。
  • 管理变量和对象。
  • 处理函数调用。
  • 执行条件判断和循环。
  • 管理异常。
  • 调用运行时库。

概念上的解释执行过程:

flowchart TB
    A["源代码或字节码"] --> B["读取指令"]
    B --> C["解析或识别指令"]
    C --> D["执行对应操作"]
    D --> E{"是否还有指令?"}
    E -->|"是"| B
    E -->|"否"| F["程序执行结束"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,这是一种简化的解释执行模型。

现代解释器不一定直接逐行读取源代码。很多解释器会先将源代码转换为 AST、字节码或其他中间表示,再执行这些表示。

1.3 编译与解释的本质区别

两者最主要的区别在于程序执行前后的处理方式。

对比维度 编译器 解释器
核心职责 转换程序表示 执行程序
主要输入 源代码或中间表示 源代码或中间表示
主要输出 目标代码或其他表示 程序执行结果
执行方式 通常先生成目标代码 由运行时驱动执行
典型代表 GCC、Clang、Rustc CPython、Ruby MRI
运行依赖 取决于目标代码和运行环境 通常需要对应运行时

编译器与解释器并不是完全对立的概念。

编译器可以生成字节码,解释器可以执行字节码;解释器也可以在运行过程中调用 JIT 编译器,将热点代码编译为机器代码。

因此,现代语言运行时经常同时包含编译和解释机制。


二、编译器的工作原理

编译器通常由多个阶段组成,每个阶段负责完成特定的代码分析或转换任务。

2.1 词法分析(Lexical Analysis)

词法分析是编译器处理源代码的第一个重要阶段。

词法分析器(Lexer)读取源代码字符流,将字符组合成具有语义类别的 Token。

例如:

int sum = a + 10;

可以识别为:

Token 类型
int 关键字
sum 标识符
= 赋值运算符
a 标识符
+ 加法运算符
10 整数字面量
; 分隔符

词法分析的主要任务:

  • 识别关键字。
  • 识别标识符。
  • 识别运算符。
  • 识别字面量。
  • 忽略空白字符和注释(具体由语言规则决定)。
  • 报告词法错误。

词法分析的结果通常是 Token 序列。

2.2 语法分析(Syntax Analysis)

语法分析器(Parser)根据语言的语法规则,检查 Token 序列是否构成合法程序结构。

例如:

int result = a + b;

语法分析器会识别:

  • 变量声明。
  • 类型声明。
  • 赋值表达式。
  • 加法表达式。
  • 语句结束符。

语法分析通常会构建抽象语法树(AST)。

示意结构:

VariableDeclaration
├── Type: int
├── Name: result
└── Initializer
    └── BinaryExpression
        ├── Left: a
        ├── Operator: +
        └── Right: b

语法分析主要负责检查程序结构是否符合语言语法,不负责判断所有变量和表达式是否具有正确的类型。

2.3 语义分析(Semantic Analysis)

语义分析负责检查程序是否符合语言的语义规则。

例如:

int a = 10;
int b = a + 20;

语义分析可能检查:

  • 变量是否已经声明。
  • 标识符是否能够正确解析。
  • 表达式类型是否兼容。
  • 函数调用参数是否匹配。
  • 作用域规则是否正确。
  • 类型转换是否合法。

例如:

int a = "hello";

这段代码在 C 语言中存在不符合类型约束的初始化问题,编译器通常会诊断相关错误。

2.4 中间表示(Intermediate Representation,IR)

中间表示是编译器内部使用的一种程序表示形式。

编译器可以将不同语言的源代码转换为统一或相对统一的 IR,再对 IR 进行分析、优化和代码生成。

例如:

int result = a + b * 2;

一种简化的三地址代码表示:

t1 = b * 2
t2 = a + t1
result = t2

IR 的主要价值:

  1. 降低源语言与目标机器之间的耦合。
  2. 支持跨平台代码生成。
  3. 便于执行编译优化。
  4. 方便进行静态分析。
  5. 支持多语言共享编译基础设施。

常见 IR 技术包括 LLVM IR、GIMPLE 和 Java 字节码等。需要注意,它们的抽象层次和设计目标并不完全相同。

2.5 代码优化(Code Optimization)

代码优化是在不改变程序规定语义的前提下,改善程序执行效率、代码体积或其他目标属性。

常见优化包括:

优化技术 作用
常量折叠 在编译阶段计算常量表达式
常量传播 将已知常量替换到后续表达式
死代码消除 删除不会影响程序结果的代码
公共子表达式消除 避免重复计算相同表达式
循环优化 改善循环执行效率
内联优化 将函数调用替换为函数体
寄存器分配 合理分配 CPU 寄存器

例如:

int a = 10;
int b = 20;
int c = a + b;

优化器可能将其转换为:

int c = 30;

这属于常量传播和常量折叠的简单示例。

实际优化还需要考虑溢出、浮点精度、可观察副作用和语言语义,不能随意改变程序行为。

2.6 代码生成(Code Generation)

代码生成阶段负责将编译器内部表示转换为目标平台所需要的代码。

常见目标包括:

  • x86-64 机器代码。
  • ARM64 机器代码。
  • WebAssembly。
  • 汇编语言。
  • 字节码。

例如:

源代码
   |
   v
中间表示
   |
   v
目标平台代码生成
   |
   v
机器指令

不同目标平台拥有不同的指令集架构(ISA),代码生成器需要根据目标架构生成对应指令。

2.7 链接(Linking)

对于需要链接的程序,编译器生成目标文件后,通常还需要链接器完成符号解析和目标文件组合。

链接器主要负责:

  • 符号解析。
  • 重定位。
  • 静态库链接。
  • 动态库依赖处理。
  • 生成可执行文件或共享库。

完整的编译与链接过程:

flowchart TB
    A["源代码"] --> B["编译器"]
    B --> C["目标文件"]
    C --> D["链接器"]
    E["静态库或动态库"] --> D
    D --> F["可执行文件"]
    F --> G["操作系统加载"]
    G --> H["程序运行"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

需要注意,编译、汇编、链接和加载是不同阶段。某些语言工具链会将其中多个阶段封装在一个命令中,但它们的职责并不相同。


三、解释器的工作原理

解释器的核心任务是执行程序表示。

不同解释器的内部架构可能差异很大,但通常涉及源代码处理、运行时数据管理和指令执行。

3.1 源代码读取

最简单的解释器可以直接读取源代码,并对其进行解析。

例如:

print(1 + 2)

解释器需要识别:

  • 函数调用。
  • 函数名称。
  • 参数列表。
  • 加法表达式。
  • 数值字面量。

但实际解释器通常不会简单地逐行读取并直接执行字符。

3.2 构建抽象语法树

很多解释器首先将源代码转换为 AST。

例如:

result = 10 + 20

可以表示为:

Assign
├── Target
│   └── Name: result
└── Value
    └── BinOp
        ├── Left: 10
        ├── Operator: Add
        └── Right: 20

AST 保留了程序的语法结构,方便后续解释执行或字节码生成。

3.3 解释执行

解释器可以遍历 AST,根据节点类型执行相应操作。

例如:

执行 Assign 节点
    |
    v
执行 BinOp 节点
    |
    v
计算左操作数
    |
    v
计算右操作数
    |
    v
执行加法
    |
    v
将结果绑定到变量 result

在实际实现中,解释器可能使用递归遍历、访问者模式、虚拟机指令分派等方式执行程序。

3.4 字节码解释

许多现代解释器会先将源代码转换为字节码,再由虚拟机执行。

以 CPython 为例,Python 源代码通常会经过解析和编译,生成代码对象,其中包含字节码等信息。

可以通过 dis 模块观察部分字节码:

import dis

def add(a, b):
    return a + b

dis.dis(add)

具体字节码指令会随着 Python 版本变化,不应将某个版本的输出视为所有版本的固定实现。

简化执行过程:

flowchart TB
    A["Python 源代码"] --> B["词法与语法处理"]
    B --> C["AST"]
    C --> D["编译为字节码"]
    D --> E["代码对象"]
    E --> F["CPython 虚拟机"]
    F --> G["执行字节码"]
    G --> H["产生运行结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

CPython 的传统执行模型主要依赖字节码解释,但现代 CPython 还包含自适应解释器等优化机制。其他 Python 实现也可能采用不同的执行策略。


四、编译器与解释器的执行方式对比

4.1 传统编译执行

传统编译执行通常先生成目标代码,再由操作系统加载并执行。

例如 C 语言:

gcc main.c -o main
./main

可以将过程概括为:

flowchart TB
    A["编写源代码"] --> B["编译"]
    B --> C["生成目标文件"]
    C --> D["链接"]
    D --> E["生成可执行文件"]
    E --> F["加载程序"]
    F --> G["CPU 执行机器指令"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

这种方式的典型特点:

  • 编译阶段可能消耗较多时间。
  • 可以提前进行大量静态分析和优化。
  • 生成的本地机器代码通常可以直接由 CPU 执行。
  • 运行时可能不需要原始源代码。
  • 可执行文件通常与目标平台和 ABI 有关。

4.2 传统解释执行

传统解释执行由解释器负责读取程序表示并执行。

例如,在 CPython 中运行:

python main.py

可以将过程概括为:

flowchart TB
    A["编写 Python 源代码"] --> B["启动 Python 解释器"]
    B --> C["解析源代码"]
    C --> D["生成代码对象"]
    D --> E["虚拟机执行字节码"]
    E --> F["调用运行时功能"]
    F --> G["输出程序结果"]

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style F fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style G fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

传统解释执行的特点:

  • 通常需要对应的解释器或运行时。
  • 代码执行依赖运行时的指令调度。
  • 便于动态加载和运行时检查。
  • 某些实现的执行开销可能较大。
  • 运行时可以动态管理对象和程序状态。

4.3 核心差异

对比维度 编译执行 解释执行
主要处理时机 通常在运行前或运行过程中生成目标代码 运行时执行程序表示
主要执行对象 目标机器代码或其他目标表示 源代码、AST、字节码等
运行时依赖 取决于目标代码及其运行环境 通常需要解释器或虚拟机
优化方式 静态优化、链接时优化、JIT 等 解释器优化、运行时优化、JIT 等
启动开销 可能有编译和加载开销 可能有解析、初始化开销
运行性能 取决于代码生成和优化质量 取决于解释器与运行时优化
跨平台性 机器代码通常依赖目标平台 字节码或源代码可由不同平台的运行时执行

不能简单地认为编译程序一定比解释程序快。

实际性能取决于:

  • 目标代码质量。
  • 运行时优化能力。
  • 程序执行模式。
  • I/O 开销。
  • 内存管理。
  • JIT 编译效果。
  • 运行时环境。

五、编译型语言与解释型语言

编程语言经常被划分为编译型语言和解释型语言。

这种分类便于初步理解语言实现,但并不是严格的语言规范分类。

同一种语言可以存在多种实现方式。

5.1 常见编译型语言

语言 常见实现方式
C 编译为本地机器代码
C++ 编译为本地机器代码
Rust 编译为本地机器代码或其他目标
Go 通常编译为本地机器代码
Swift 通常通过编译工具链生成目标代码

这些语言通常采用编译工具链,将源代码转换为目标平台可以执行的代码。

5.2 常见解释执行或虚拟机语言

语言 常见实现方式
Python CPython 通常编译为字节码并由虚拟机解释执行
Ruby MRI 通常使用字节码虚拟机
PHP 常见实现通过 Zend Engine 执行编译后的操作码
JavaScript 现代引擎通常结合字节码解释与 JIT 编译

这些语言并不一定采用纯粹的逐行解释方式。

5.3 Java 为什么既编译又解释?

Java 是理解混合执行模型的典型案例。

Java 源代码通常先通过 javac 编译为 JVM 字节码。

javac Main.java
java Main

生成的 .class 文件包含 JVM 字节码。

JVM 可以通过解释器执行字节码,也可以使用 JIT 编译器将热点代码编译为本地机器代码。

flowchart TB
    A["Java 源代码"] --> B["javac 编译"]
    B --> C["JVM 字节码"]
    C --> D["JVM 加载与验证"]
    D --> E["解释器执行"]
    D --> F["热点代码分析"]
    F --> G["JIT 编译"]
    G --> H["本地机器代码"]
    E --> I["程序运行"]
    H --> I

    style A fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style B fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style C fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style D fill:#FFF5DE,stroke:#E8D29A,color:#334155
    style E fill:#E8EDF2,stroke:#B8C3CE,color:#334155
    style F fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    style G fill:#F3EDFC,stroke:#C4B2E3,color:#334155
    style H fill:#E0F0FE,stroke:#93BCE8,color:#1E4976
    style I fill:#E5F4EC,stroke:#A3CBB5,color:#334155
    linkStyle default stroke:#A3B8AC,stroke-width:1.5px

Java 的执行过程包含多个阶段:

  1. javac 将源代码编译为字节码。
  2. JVM 加载并验证字节码。
  3. 解释器可以先执行字节码。
  4. JVM 收集运行时性能信息。
  5. JIT 编译器识别热点代码。
  6. 热点代码被编译为本地机器代码。
  7. 后续执行可以使用优化后的机器代码。

因此,Java 既具有编译阶段,也具有解释执行和即时编译阶段。

5.4 JavaScript 为什么也需要 JIT?

现代 JavaScript 引擎通常采用多层执行架构。

以 V8 为例,其执行过程可能涉及:

  • 源代码解析。
  • AST 构建。
  • 字节码生成。
  • 解释执行。
  • 热点代码分析。
  • 优化编译。
  • 反优化。

简化过程: