1. 项目概述：为什么用C++手搓一个编译器？

如果你对编程的理解还停留在“调用库函数实现业务逻辑”的层面，那么亲手用C++构建一个编译器，无疑是打通任督二脉的终极修炼。这不仅仅是实现一个工具，更是对计算机如何“理解”并“执行”你写的代码，进行一次从底层开始的、全景式的深度探索。最近看到不少朋友在搜“C++八股文”、“C++面试题”，说实话，背那些东西远不如亲手实现一个编译器来得深刻。当你自己处理了词法分析、语法树构建、语义检查和代码生成，那些面试里关于内存管理、多态实现、编译优化的问题，瞬间就有了血肉。

这个项目，我们将从零开始，构建一个能处理简单算术表达式和变量赋值的“迷你编译器”。它最终可能不会生成x86汇编，而是生成一种我们自定义的、易于理解的中间指令或伪汇编。选择C++，是因为它足够底层，能让我们精细控制内存和数据结构（比如手搓链表来实现语法树），同时又足够高级，避免陷入汇编的繁琐细节。整个过程，你会清晰地看到，你写的a = b + c * 2是如何一步步被拆解、分析，并最终“翻译”成机器可执行的动作序列的。这比任何理论教材都来得直观。

2. 编译器整体架构与核心模块设计

一个编译器，无论大小，其核心工作流都可以抽象为一条清晰的“流水线”。我们的迷你编译器也将遵循经典的设计，主要包含四个核心阶段。

2.1 核心阶段分解：从源代码到目标代码

1. 词法分析器：这是编译器的“眼睛”。它的任务是把源代码字符串（比如"int a = 5 + 3;"）切割成一个个有意义的“单词”，在编译原理中称为“词法单元”或“Token”。例如，它会识别出int是关键字，a是标识符，=是操作符，5是整型字面量，+是操作符，3是整型字面量，;是分号。这个过程会过滤掉空格、换行、注释等无关字符。

2. 语法分析器：这是编译器的“大脑语法区”。它接收Token流，并根据预定义的语法规则（通常用上下文无关文法描述），检查这些Token的排列组合是否符合语法。如果符合，它会构建出一棵“抽象语法树”。这棵树以层次化的结构表达了代码的语法结构。例如，表达式5 + 3 * 2对应的AST会明确表示乘法*的优先级高于加法+，而不是简单的从左到右。

3. 语义分析器（可选但建议实现）：这是编译器的“逻辑校验器”。它在AST的基础上进行，检查程序是否“有意义”。例如，变量在使用前是否已声明？赋值语句左右两边的类型是否匹配？函数调用的参数个数和类型是否正确？对于我们的迷你编译器，可以实现简单的类型检查和变量作用域管理。

4. 代码生成器：这是编译器的“翻译官”。它遍历经过语义检查的AST，为每一种语法结构（如赋值、算术运算、条件判断）生成对应的目标代码。目标代码可以是真实的汇编（如x86、ARM），也可以是我们自定义的虚拟机字节码或简单的三地址码，这取决于项目的复杂度和目标。

2.2 数据结构设计：Token与AST节点

在编码之前，我们需要定义两个贯穿始终的核心数据结构。

Token结构体：用于承载词法分析的结果。

struct Token { enum class Type { Keyword, // 如 int, if, while Identifier, // 如变量名 a, count Literal, // 如数字 42, 字符串 "hello" Operator, // 如 +, -, *, /, =, == Delimiter, // 如 ;, ,, (, ), {, } EndOfFile // 文件结束标记 }; Type type; std::string value; // Token对应的原始字符串 size_t line; // 所在行号，用于错误提示 size_t column; // 所在列号 Token(Type t, const std::string& v, size_t l, size_t c) : type(t), value(v), line(l), column(c) {} };

AST节点基类与派生类：用于构建语法树。这里采用多态来实现不同类型的节点。

// AST节点基类 class ASTNode { public: virtual ~ASTNode() = default; virtual void print(int indent = 0) const = 0; // 用于调试打印树结构 // 后续可以添加 accept(Visitor&) 方法用于访问者模式，便于代码生成和优化 }; // 二元运算节点（例如 a + b, c = d） class BinaryOpNode : public ASTNode { public: Token op; // 操作符 Token std::unique_ptr<ASTNode> left; std::unique_ptr<ASTNode> right; BinaryOpNode(Token opTok, std::unique_ptr<ASTNode> l, std::unique_ptr<ASTNode> r) : op(std::move(opTok)), left(std::move(l)), right(std::move(r)) {} void print(int indent) const override { // 打印逻辑，展示树形结构 } }; // 字面量节点（例如数字 5） class LiteralNode : public ASTNode { public: Token valueToken; LiteralNode(Token tok) : valueToken(std::move(tok)) {} void print(int indent) const override { /* ... */ } }; // 标识符节点（例如变量名 a） class IdentifierNode : public ASTNode { public: Token idToken; IdentifierNode(Token tok) : idToken(std::move(tok)) {} void print(int indent) const override { /* ... */ } };

设计心得：使用std::unique_ptr<ASTNode>来管理子树所有权，可以避免内存泄漏的麻烦，也清晰地表达了树的层次关系。Token中保存行列信息在报错时极其有用，能快速定位源代码中的问题位置。

3. 词法分析器：编译器的“分词引擎”

词法分析器，也叫扫描器，是编译器的第一道工序。它的实现本质是一个确定有限状态自动机。我们不需要手动画状态转移图，而是可以通过顺序扫描字符并配合条件判断来实现。

3.1 核心扫描逻辑与状态判断

我们创建一个Lexer类，其核心是一个getNextToken()方法。

class Lexer { private: std::string sourceCode; size_t position; // 当前读取位置 size_t line; size_t column; char currentChar() const { return position < sourceCode.length() ? sourceCode[position] : '\0'; } void advance() { /* 移动 position，更新 column 和 line */ } public: Lexer(const std::string& code) : sourceCode(code), position(0), line(1), column(1) {} Token getNextToken(); };

getNextToken()的内部实现，就是一系列if-else或switch判断：

1. 跳过空白：遇到空格、制表符、换行符，直接跳过并更新行列计数器。
2. 识别数字：如果当前字符是数字，则持续读取直到非数字字符，形成一个完整的数字字面量字符串，生成Token::Type::Literal。
3. 识别标识符和关键字：如果当前字符是字母或下划线，则持续读取字母、数字或下划线。读取完成后，检查该字符串是否是预定义的关键字（如"int","if"）。如果是，生成Token::Type::Keyword；否则，生成Token::Type::Identifier。
4. 识别操作符和分隔符：对于单字符操作符如+,-,*,/,;,,,(,)等，直接生成对应Token。对于可能的多字符操作符（如==,!=,>=,<=），需要“向前看”一个字符（peek）来判断。
5. 处理注释：如果遇到//，则一直读到行尾并丢弃；如果遇到/*，则需要一直读到*/出现。这是一个容易出错的地方，特别是嵌套注释（我们通常不支持）。
6. 文件结束：当读到字符串末尾时，返回一个Token::Type::EndOfFile。

3.2 关键实现细节与避坑指南

Token Lexer::getNextToken() { // 1. 跳过空白字符 while (std::isspace(currentChar())) { if (currentChar() == '\n') { line++; column = 1; } else { column++; } advance(); } // 2. 处理文件结束 if (currentChar() == '\0') { return Token(Token::Type::EndOfFile, "", line, column); } // 3. 识别数字字面量 if (std::isdigit(currentChar())) { size_t startCol = column; std::string numStr; while (std::isdigit(currentChar())) { numStr += currentChar(); advance(); column++; } // 这里可以扩展支持浮点数、十六进制等 return Token(Token::Type::Literal, numStr, line, startCol); } // 4. 识别标识符和关键字 if (std::isalpha(currentChar()) || currentChar() == '_') { size_t startCol = column; std::string idStr; while (std::isalnum(currentChar()) || currentChar() == '_') { idStr += currentChar(); advance(); column++; } // 关键字判断 static const std::unordered_set<std::string> keywords = {"int", "if", "else", "while", "return"}; if (keywords.find(idStr) != keywords.end()) { return Token(Token::Type::Keyword, idStr, line, startCol); } return Token(Token::Type::Identifier, idStr, line, startCol); } // 5. 识别操作符和分隔符 char c = currentChar(); size_t startCol = column; advance(); column++; switch (c) { case '+': return Token(Token::Type::Operator, "+", line, startCol); case '-': return Token(Token::Type::Operator, "-", line, startCol); case '*': return Token(Token::Type::Operator, "*", line, startCol); case '/': // 处理注释 if (currentChar() == '/') { // 单行注释 while (currentChar() != '\0' && currentChar() != '\n') { advance(); } column = 1; line++; advance(); // 吃掉换行符 return getNextToken(); // 递归调用，获取注释后的下一个Token } else if (currentChar() == '*') { // 多行注释 // 实现略，需要小心处理未闭合的注释 advance(); column++; while (!(currentChar() == '*' && peekChar() == '/')) { if (currentChar() == '\0') { throw std::runtime_error("Unterminated comment at line " + std::to_string(line)); } if (currentChar() == '\n') { line++; column = 1; } else { column++; } advance(); } advance(); advance(); // 跳过 `*/` column += 2; return getNextToken(); } else { return Token(Token::Type::Operator, "/", line, startCol); } case '=': if (currentChar() == '=') { advance(); column++; return Token(Token::Type::Operator, "==", line, startCol); } return Token(Token::Type::Operator, "=", line, startCol); case ';': return Token(Token::Type::Delimiter, ";", line, startCol); case '(': return Token(Token::Type::Delimiter, "(", line, startCol); case ')': return Token(Token::Type::Delimiter, ")", line, startCol); case '{': return Token(Token::Type::Delimiter, "{", line, startCol); case '}': return Token(Token::Type::Delimiter, "}", line, startCol); // ... 其他字符处理 default: throw std::runtime_error("Unexpected character '" + std::string(1, c) + "' at line " + std::to_string(line) + ":" + std::to_string(startCol)); } }

避坑指南：

1. 行列计数：在advance()函数中统一管理行列号更新，比在每个判断分支里手动更新更可靠，避免遗漏。
2. “向前看”字符：实现一个peekChar()函数（查看下一个字符但不移动position），对于识别==,!=,>=,<=等多字符操作符至关重要。
3. 错误恢复：简单的词法分析器在遇到无法识别的字符时可以直接报错退出。更健壮的实现可以尝试跳过非法字符并继续扫描，但这对初学者来说增加了复杂度。
4. 注释处理：务必在注释处理逻辑的末尾递归调用getNextToken()，或者使用循环，以确保返回的是注释之后的有效Token，而不是直接返回。这是新手常犯的错误。

4. 语法分析器：构建程序的“语法树”

语法分析器，也叫解析器，是编译器的核心。它将线性的Token序列，根据语法规则，组装成树形的抽象语法树。我们采用递归下降分析法来实现，这是最直观、最适合手写解析器的方法。它的核心思想是：为语法规则中的每一个非终结符（如“表达式”、“语句”）编写一个对应的解析函数。

4.1 文法定义与递归下降函数映射

首先，我们需要为我们的迷你语言定义一个简单的文法。这里使用扩展巴科斯范式（EBNF）描述：

program := statement* statement := declaration | assignment | ifStatement | whileStatement | block declaration := 'int' identifier ('=' expression)? ';' assignment := identifier '=' expression ';' ifStatement := 'if' '(' expression ')' block ('else' block)? whileStatement := 'while' '(' expression ')' block block := '{' statement* '}' expression := additiveExpression additiveExpression := multiplicativeExpression (('+' | '-') multiplicativeExpression)* multiplicativeExpression := primaryExpression (('*' | '/') primaryExpression)* primaryExpression := identifier | literal | '(' expression ')'

根据这个文法，我们可以在Parser类中创建对应的解析函数：

• parseProgram()-> 解析整个程序
• parseStatement()-> 解析语句
• parseDeclaration()-> 解析变量声明
• parseExpression()-> 解析表达式
• parseAdditiveExpression()-> 解析加减表达式
• parseMultiplicativeExpression()-> 解析乘除表达式
• parsePrimaryExpression()-> 解析基本表达式（标识符、字面量、括号表达式）

4.2 表达式解析与运算符优先级处理

表达式解析是语法分析中最经典的部分，关键在于处理运算符的优先级（乘除高于加减）和结合性（左结合）。递归下降法通过函数调用的层次来天然地体现优先级。

class Parser { private: Lexer& lexer; Token currentToken; void eat(Token::Type expectedType) { if (currentToken.type == expectedType) { currentToken = lexer.getNextToken(); } else { throw std::runtime_error("Syntax error: expected ... at line " + std::to_string(currentToken.line)); } } Token peekToken() { /* 偷看下一个Token，不消费 */ } public: Parser(Lexer& l) : lexer(l) { currentToken = lexer.getNextToken(); // 初始化，获取第一个Token } // 解析表达式入口 std::unique_ptr<ASTNode> parseExpression() { return parseAdditiveExpression(); } // 解析加减表达式 std::unique_ptr<ASTNode> parseAdditiveExpression() { // 先解析一个乘除表达式作为左子树 auto left = parseMultiplicativeExpression(); // 循环处理连续的加减操作符 while (currentToken.type == Token::Type::Operator && (currentToken.value == "+" || currentToken.value == "-")) { Token op = currentToken; eat(Token::Type::Operator); // 消费掉操作符Token auto right = parseMultiplicativeExpression(); // 解析右子树（同样是乘除表达式） // 将当前的左子树和新的右子树，用刚读到的操作符组合成一个新的二元运算节点 left = std::make_unique<BinaryOpNode>(std::move(op), std::move(left), std::move(right)); } return left; // 返回构建好的子树 } // 解析乘除表达式 std::unique_ptr<ASTNode> parseMultiplicativeExpression() { auto left = parsePrimaryExpression(); // 先解析基本表达式 while (currentToken.type == Token::Type::Operator && (currentToken.value == "*" || currentToken.value == "/")) { Token op = currentToken; eat(Token::Type::Operator); auto right = parsePrimaryExpression(); left = std::make_unique<BinaryOpNode>(std::move(op), std::move(left), std::move(right)); } return left; } // 解析基本表达式：标识符、字面量或括号表达式 std::unique_ptr<ASTNode> parsePrimaryExpression() { if (currentToken.type == Token::Type::Identifier) { auto node = std::make_unique<IdentifierNode>(currentToken); eat(Token::Type::Identifier); return node; } else if (currentToken.type == Token::Type::Literal) { auto node = std::make_unique<LiteralNode>(currentToken); eat(Token::Type::Literal); return node; } else if (currentToken.type == Token::Type::Delimiter && currentToken.value == "(") { eat(Token::Type::Delimiter); // 吃掉 '(' auto expr = parseExpression(); // 递归解析括号内的表达式 if (!(currentToken.type == Token::Type::Delimiter && currentToken.value == ")")) { throw std::runtime_error("Expected ')'"); } eat(Token::Type::Delimiter); // 吃掉 ')' return expr; } else { throw std::runtime_error("Unexpected token in primary expression"); } } // 解析赋值语句 std::unique_ptr<ASTNode> parseAssignment() { // 假设当前Token是标识符 Token idToken = currentToken; eat(Token::Type::Identifier); Token opToken = currentToken; // 应该是 '=' eat(Token::Type::Operator); auto expr = parseExpression(); eat(Token::Type::Delimiter); // 吃掉 ';' return std::make_unique<BinaryOpNode>(std::move(opToken), std::make_unique<IdentifierNode>(std::move(idToken)), std::move(expr)); } };

实操心得：

1. eat()函数是核心：它负责消费（匹配）一个期望类型的Token，如果类型不匹配则报错。这是递归下降解析器的“推进器”。
2. 优先级是通过函数调用层次实现的：parseExpression->parseAdditiveExpression->parseMultiplicativeExpression->parsePrimaryExpression。调用链越深，优先级越高。parseAdditiveExpression在遇到乘除号时，会调用优先级更高的parseMultiplicativeExpression来处理。
3. 左结合性的实现：注意在parseAdditiveExpression和parseMultiplicativeExpression中的while循环。对于表达式a + b + c，它会被解析为((a + b) + c)，这正是左结合。循环不断将新的操作符和右子树与当前的左子树结合，构建出正确的AST。
4. 错误处理：目前的错误处理很简陋。一个更健壮的解析器应该能尝试从错误中恢复（比如跳过直到下一个分号），并收集多个错误一次性报告。

5. 语义分析：为程序注入“逻辑灵魂”

语法分析只关心“形式”是否正确，而语义分析则关心“含义”是否合法。对于我们的迷你编译器，语义分析主要做两件事：符号表管理和类型检查。

5.1 符号表的设计与作用域管理

符号表是一个数据结构，用于记录程序中所有声明过的标识符（主要是变量）的信息，包括名称、类型、作用域、内存位置（如果后续需要分配）等。最简单的实现是一个std::unordered_map<std::string, Symbol>。

作用域是语义分析的关键。当进入一个代码块（由{}包围）时，就进入了一个新的作用域。新的声明会添加到当前作用域。当离开这个代码块时，该作用域内的所有声明都应该失效。这通常通过“作用域栈”来实现。

struct Symbol { std::string name; std::string type; // 例如 "int" // 其他属性，如是否初始化，内存偏移量等 }; class SymbolTable { private: std::vector<std::unordered_map<std::string, Symbol>> scopes; // 作用域栈 public: void enterScope() { scopes.push_back({}); } void exitScope() { if (!scopes.empty()) { scopes.pop_back(); } } bool addSymbol(const Symbol& sym) { if (scopes.empty()) enterScope(); auto& currentScope = scopes.back(); // 检查当前作用域是否已存在同名符号（禁止重复声明） if (currentScope.find(sym.name) != currentScope.end()) { return false; // 重复声明错误 } currentScope[sym.name] = sym; return true; } std::optional<Symbol> lookup(const std::string& name) { // 从最内层作用域向外查找 for (auto it = scopes.rbegin(); it != scopes.rend(); ++it) { auto found = it->find(name); if (found != it->end()) { return found->second; } } return std::nullopt; // 未找到 } };

5.2 类型检查与AST遍历

语义分析需要对AST进行遍历。我们可以采用访问者模式，为每种AST节点定义相应的“访问”行为。这里为了简化，我们直接在解析过程中进行简单的语义检查。

例如，在parseDeclaration函数中：

1. 当遇到int a;时，调用symbolTable.addSymbol({"a", "int"})。
2. 在parseAssignment或parseExpression中，当遇到一个标识符时（在parsePrimaryExpression里），调用symbolTable.lookup(identifierName)。如果返回std::nullopt，则报错“未声明的变量”。
3. 在parseAssignment中，赋值号=左边的表达式必须是一个“左值”（目前就是标识符）。同时，可以检查赋值号左右两边的类型是否兼容（在我们的迷你语言里，暂时只有int类型，所以总是兼容）。

更复杂的类型检查，比如检查if条件表达式的结果是否为布尔类型，或者函数调用参数匹配，都需要在对应的解析函数中嵌入检查逻辑。

注意事项：语义分析阶段是发现诸如“使用了未定义的变量”、“类型不匹配”等逻辑错误的最佳时机。将符号表管理好，能极大简化后续代码生成阶段的工作，尤其是为变量分配存储位置时。

6. 代码生成：从AST到可执行指令

代码生成是编译器的最后一步，也是最贴近机器的一步。为了简化，我们不直接生成x86汇编，而是生成一种简单的三地址码或栈式虚拟机字节码。这里以生成一种人类可读的伪指令为例。

6.1 目标代码选择：三地址码简介

三地址码的基本形式是：result = arg1 op arg2。每个指令最多涉及三个地址（变量或临时变量）。它非常接近现代处理器的指令，但又独立于具体硬件。

例如，对于表达式x = a + b * c，可能生成以下三地址码序列：

t1 = b * c t2 = a + t1 x = t2

6.2 遍历AST生成指令

我们同样通过遍历AST来生成代码。为每种AST节点类型编写一个代码生成方法。

class CodeGenerator { private: std::vector<std::string> instructions; int tempVarCounter = 0; SymbolTable& symTable; // 需要符号表来查询变量信息 std::string newTemp() { return "t" + std::to_string(tempVarCounter++); } public: CodeGenerator(SymbolTable& st) : symTable(st) {} std::string generateCode(ASTNode* root) { // 假设root是一个语句列表的节点 // 遍历所有语句，为每个语句生成代码 // 这里简化处理，假设root是单个表达式或赋值语句 return evaluate(root); // evaluate函数返回一个“地址”（变量名或临时变量名） } // 评估一个表达式节点，返回存储结果的变量名 std::string evaluate(ASTNode* node) { if (auto* binOp = dynamic_cast<BinaryOpNode*>(node)) { std::string leftAddr = evaluate(binOp->left.get()); std::string rightAddr = evaluate(binOp->right.get()); if (binOp->op.value == "=") { // 赋值语句 // 假设左子树是IdentifierNode auto* leftId = dynamic_cast<IdentifierNode*>(binOp->left.get()); if (!leftId) { /* 错误处理 */ } instructions.push_back(leftId->idToken.value + " = " + rightAddr); return leftId->idToken.value; } else { // 算术运算 std::string temp = newTemp(); instructions.push_back(temp + " = " + leftAddr + " " + binOp->op.value + " " + rightAddr); return temp; } } else if (auto* idNode = dynamic_cast<IdentifierNode*>(node)) { // 返回变量名本身 // 这里可以检查变量是否在符号表中已声明 return idNode->idToken.value; } else if (auto* litNode = dynamic_cast<LiteralNode*>(node)) { // 返回字面量值 return litNode->valueToken.value; } return ""; } void printInstructions() const { for (const auto& instr : instructions) { std::cout << instr << std::endl; } } };

对于更复杂的控制流（如if,while），代码生成需要处理标签和跳转指令。例如，if (cond) { stmt1; } else { stmt2; }可以生成如下伪代码：

<cond_code> // 计算条件表达式，结果存入某个临时变量或标志位 JUMP_IF_FALSE <else_label> <cond_result> <stmt1_code> JUMP <end_label> else_label: <stmt2_code> end_label:

6.3 简单的优化考虑

即使在迷你编译器中，也可以实现一两个简单的优化，让生成的代码更高效：

1. 常量折叠：在语法分析或语义分析阶段，如果发现一个表达式的所有操作数都是常量（如3 + 5 * 2），可以直接计算出结果（13），并用一个LiteralNode代替整个子树，避免生成无用的计算指令。
2. 公共子表达式消除：如果同一表达式在同一个作用域内被计算多次，可以将其结果存入一个临时变量，后续直接使用该变量。这需要更复杂的数据流分析，对于入门项目可以暂缓。

代码生成心得：代码生成器是“知道最多”的模块。它既要知道AST的结构，又要知道目标指令集的特点，还要管理临时变量和标签。设计一个清晰、模块化的代码生成器接口非常重要。可以考虑使用访问者模式，将AST遍历和代码生成逻辑分离，这样以后更换目标平台（比如从伪指令换成真实汇编）会更容易。

7. 集成测试与常见问题排查

将词法分析、语法分析、语义分析和代码生成模块串联起来，就构成了一个完整的编译器前端。我们可以编写一个小型测试框架来验证各个模块。

7.1 构建端到端测试流程

创建一个简单的main函数：

int main() { std::string sourceCode = R"( int a; int b; a = 5; b = a + 3 * 2; )"; try { // 1. 词法分析 Lexer lexer(sourceCode); // 可以测试：打印所有Token // Token tok; // do { // tok = lexer.getNextToken(); // std::cout << "Token: " << tok.value << std::endl; // } while (tok.type != Token::Type::EndOfFile); // 2. 语法分析 & 语义分析 Parser parser(lexer); SymbolTable symTable; // 我们需要将symTable传递给Parser，或者在Parser中创建并填充它 // 假设Parser有一个parseProgram方法返回AST根节点 std::unique_ptr<ASTNode> astRoot = parser.parseProgram(); // 3. 打印AST（调试用） // astRoot->print(); // 4. 代码生成 CodeGenerator codeGen(symTable); codeGen.generateCode(astRoot.get()); codeGen.printInstructions(); } catch (const std::exception& e) { std::cerr << "Compilation Error: " << e.what() << std::endl; return 1; } return 0; }

7.2 常见编译错误与调试技巧

在开发编译器过程中，你会遇到各种错误。以下是一个快速排查指南：

调试利器：

• 打印Token流：在词法分析后，将识别出的所有Token类型和值打印出来，这是验证“分词”是否正确的最直接方法。
• 打印AST：为ASTNode实现一个格式化的print(int indent)方法，可以直观地看到语法树的结构，对于调试优先级和结合性错误至关重要。
• 单元测试：为每个模块（Lexer,Parser中的各个函数）编写小的单元测试，例如测试parsePrimaryExpression是否能正确解析数字、变量和括号表达式。这能极大提升开发效率。

8. 项目扩展与进阶思考

完成一个基础编译器后，你可以选择多个方向进行深化，这会让你的理解再上一个台阶。

8.1 支持更复杂的语言特性

1. 控制流：实现if-else和while语句。这需要代码生成器支持标签和条件/无条件跳转指令。
2. 函数：这是质的飞跃。需要处理函数声明、参数传递、调用约定、返回值和栈帧管理。你会深入理解“调用栈”的概念。
3. 数组和结构体：引入更复杂的数据类型，涉及到连续内存布局和地址计算。
4. 简单的类型系统：加入float、bool、char类型，并实现基本的类型转换规则。

8.2 优化策略初探

1. 常量传播：如果一个变量被赋值为常量，那么在所有使用该变量的地方，只要其值没有被重新赋值，就可以直接用常量替换。
2. 死代码消除：移除永远不会被执行到的代码（如if (false) { ... }）或者计算结果永远不会被使用的代码。
3. 窥孔优化：在一个很小的指令窗口（如相邻的两三条指令）内寻找可以替换为更高效指令的模式。例如，将t = a + 0优化为t = a。

8.3 转向真实目标平台

1. 生成LLVM IR：LLVM提供了一个与硬件无关的中间表示层。将你的AST转换为LLVM IR，然后利用LLVM强大的后端，可以轻松生成x86、ARM等多种架构的优化后汇编代码。这是现代编译器（如Clang）的做法。
2. 生成x86汇编：你可以学习x86汇编的基础知识，然后自己将三地址码映射到有限的几条x86指令（如mov,add,imul,cmp,jmp等），并使用系统调用或调用C库函数来实现输入输出。这是最硬核、收获最大的方式，能让你对程序如何在CPU上运行有刻骨铭心的理解。

手写编译器是一个庞大的工程，但这个迷你版本已经涵盖了所有核心概念。当你看到自己写的程序，经过自己打造的编译器，变成一串串指令并最终执行时，那种成就感是无与伦比的。这不仅仅是学会了一项技能，更是获得了一种深刻理解计算机系统的“元能力”。