C++如何实现一个简单的AST_使用C++构建抽象语法树并进行代码解析

新闻中心 NEWS CENTER

您当前位置：首页 > 新闻中心 > 网络学院

C++如何实现一个简单的AST_使用C++构建抽象语法树并进行代码解析

2025-11-30

浏览次数：次

返回列表

答案：文章介绍了在C++中构建简单抽象语法树（AST）的过程，涵盖节点基类定义、具体节点类型实现、变量环境管理、词法分析器与递归下降解析器的设计，并通过示例展示表达式解析与求值流程。

c++如何实现一个简单的ast_使用c++构建抽象语法树并进行代码解析

在C++中实现一个简单的抽象语法树（AST）是理解编译器或解释器工作原理的关键一步。AST 是源代码结构的树形表示，它忽略掉源码中的语法细节（如括号、分号），专注于程序的逻辑结构。下面我们将一步步构建一个极简的 AST，并结合词法分析和语法分析来解析简单表达式。

1. 定义AST节点基类

所有AST节点都应继承自一个公共基类。我们使用多态来处理不同类型的节点，比如数字、变量、二元操作等。

#include <memory>
#include <string>
#include <map>
#include <iostream>
<p>// 所有AST节点的基类
struct ExprAST {
virtual ~ExprAST() = default;
virtual double evaluate() const = 0; // 解释执行接口
};</p>

2. 实现具体节点类型

根据常见表达式元素，定义几种基本节点：

数字节点：表示常量值
二元操作节点：如加减乘除
变量节点：表示标识符
赋值节点：将值绑定到变量

// 数字常量节点
struct NumberExprAST : ExprAST {
    double val;
    explicit NumberExprAST(double v) : val(v) {}
    double evaluate() const override { return val; }
};
<p>// 变量节点
struct VariableExprAST : ExprAST {
std::string name;
explicit VariableExprAST(const std::string &n) : name(n) {}
double evaluate() const override;
};</p><p>// 二元操作节点（+、-、*、/）
struct BinaryExprAST : ExprAST {
char op;
std::unique_ptr<ExprAST> lhs, rhs;</p><pre class='brush:php;toolbar:false;'>BinaryExprAST(char o, std::unique_ptr<ExprAST> l, std::unique_ptr<ExprAST> r)
    : op(o), lhs(std::move(l)), rhs(std::move(r)) {}

double evaluate() const override;

};

// 赋值节点 struct AssignmentExprAST : ExprAST { std::string varName; std::unique_ptr expr;

AssignmentExprAST(const std::string &name, std::unique_ptr<ExprAST> e)
    : varName(name), expr(std::move(e)) {}

double evaluate() const override;

};

这些节点通过重写 evaluate 方法实现求值逻辑。变量和赋值需要访问一个全局变量环境。

3. 添加变量环境支持

我们需要一个地方存储变量值。使用一个简单的 map 即可。

static std::map<std::string, double> variableValues;
<p>double VariableExprAST::evaluate() const {
auto it = variableValues.find(name);
if (it != variableValues.end()) return it->second;
return 0.0; // 未定义变量默认为0
}</p><p>double AssignmentExprAST::evaluate() const {
double val = expr->evaluate();
variableValues[varName] = val;
return val;
}</p>

4. 简单的词法分析器（Tokenizer）

将输入字符串拆分为 token 流。这里只处理数字、字母、操作符和空格。

class Lexer {
    std::string input;
    size_t pos = 0;
<p>public:
explicit Lexer(const std::string &src) : input(src) {}</p><pre class='brush:php;toolbar:false;'>int getNextToken() {
    while (pos < input.size() && isspace(input[pos]))
        pos++;

    if (pos >= input.size()) return 0; // EOF

    if (isdigit(input[pos]) || input[pos] == '.') {
        std::string numStr;
        while (pos < input.size() && (isdigit(input[pos]) || input[pos] == '.'))
            numStr += input[pos++];
        lastNum = stod(numStr);
        return 'n'; // number token
    }

    if (isalpha(input[pos])) {
        std::string name;
        while (pos < input.size() && isalnum(input[pos]))
            name += input[pos++];
        lastIdentifier = name;
        return 'v'; // variable or identifier
    }

    if (input[pos] == '=') {
        pos++;
        return '='; // assignment
    }

    return input[pos++]; // operator or punctuation
}

double lastNum;
std::string lastIdentifier;

};

5. 递归下降解析器

实现一个简单的递归下降解析器来构建AST。我们支持如下文法：

GoEnhance

全能AI视频制作平台：通过GoEnhance AI让视频创作变得比以往任何时候都更简单。

347 查看详情 GoEnhance

表达式 → 赋值表达式
赋值表达式 → 标识符 '=' 表达式 | 加减表达式
加减表达式 → 乘除表达式的序列（用 + 或 - 连接）
乘除表达式 → 原子表达式的序列（用 * 或 / 连接）
原子表达式 → 数字 | 变量 | (表达式)

class Parser {
    Lexer lexer;
    int currentToken;
<pre class='brush:php;toolbar:false;'>void advance() { currentToken = lexer.getNextToken(); }

std::unique_ptr<ExprAST> parsePrimary();
std::unique_ptr<ExprAST> parseExpression();
std::unique_ptr<ExprAST> parseBinOpRHS(int precedence, std::unique_ptr<ExprAST> lhs);
std::unique_ptr<ExprAST> parseAssignment();

public: explicit Parser(const std::string &src) : lexer(src) { advance(); // 初始化第一个token }

std::unique_ptr<ExprAST> parse();

};

std::unique_ptr Parser::parse() { if (currentToken == 0) return nullptr; return parseAssignment(); }

std::unique_ptr Parser::parseAssignment() { if (currentToken == 'v') { std::string idName = lexer.lastIdentifier; advance(); if (currentToken == '=') { advance(); auto expr = parseExpression(); if (!expr) return nullptr; return std::make_unique(idName, std::move(expr)); } // 不是赋值，则回退为普通变量使用 return std::make_unique(idName); } return parseExpression(); }

// 支持优先级的二元表达式解析 std::unique_ptr Parser::parseExpression() { auto lhs = parsePrimary(); if (!lhs) return nullptr; return parseBinOpRHS(0, std::move(lhs)); }

int getOperatorPrecedence(char op) { switch (op) { case '+': case '-': return 1; case '*': case '/': return 2; default: return -1; } }

std::unique_ptr Parser::parseBinOpRHS(int precedence, std::unique_ptr lhs) { while (true) { int prec = getOperatorPrecedence(currentToken); if (prec

    char op = currentToken;
    advance();

    auto rhs = parsePrimary();
    if (!rhs) return nullptr;

    int nextPrec = getOperatorPrecedence(currentToken);
    if (nextPrec > prec) {
        rhs = parseBinOpRHS(prec + 1, std::move(rhs));
        if (!rhs) return nullptr;
    }

    lhs = std::make_unique<BinaryExprAST>(op, std::move(lhs), std::move(rhs));
}

}

std::unique_ptr Parser::parsePrimary() { switch (currentToken) { case 'n': { auto result = std::make_unique(lexer.lastNum); advance(); return result; } case 'v': { auto result = std::make_unique(lexer.lastIdentifier); advance(); return result; } case '(': { advance(); // consume '(' auto expr = parseExpression(); if (currentToken != ')') { std::cerr

// 二元操作求值实现 double BinaryExprAST::evaluate() const { double L = lhs->evaluate(); double R = rhs->evaluate(); switch (op) { case '+': return L + R; case '-': return L - R; case '': return L R; case '/': return L / R; default: return 0.0; } }

6. 使用示例

现在我们可以测试整个流程：

int main() {
    std::string input;
    std::cout << "Enter expression (e.g., a=3+4*2): ";
    std::getline(std::cin, input);
<pre class='brush:php;toolbar:false;'>Parser parser(input);
auto ast = parser.parse();

if (ast) {
    double result = ast->evaluate();
    std::cout << "Result: " << result << "\n";
    std::cout << "Variables:\n";
    for (const auto& [name, val] : variableValues) {
        std::cout << "  " << name << " = " << val << "\n";
    }
} else {
    std::cerr << "Parse error.\n";
}

return 0;

}

运行示例：

输入：a=3+4*2
输出：Result: 11
      Variables: a = 11

这个例子展示了如何从零开始构建一个可运行的 AST 系统。虽然功能简单，但它具备了真实编译器前端的核心组件：词法分析、语法分析、AST 构建与解释执行。

基本上就这些。你可以在此基础上扩展函数定义、控制流语句（if、while）、作用域管理等功能，逐步演化成一个完整的解释型语言前端。

以上就是C++如何实现一个简单的AST_使用C++构建抽象语法树并进行代码解析的详细内容，更多请关注其它相关文章！

# 多态 # 莆田鞋营销推广话术模板 # 百度关键词排名找谁查看 # 商业网站建设pdf # 黔东模板网站优化平台 # 南坪正规seo公司 # 长垣网站seo优化推广 # SEO首页是啥意思 # 焦作搜索关键词排名精准 # 增城企业网站seo # 会展营销推广软文 # 构建一个 # 加减 # 求值 # 解决方法 # c++ # 全局变量 # 如何实现 # 有什么 # 重写 # 递归 # 作用域 # stream # switch # ios # ai # 字节 # git # 前端 # 抽象语法树

相关栏目：【科技资讯46185 】【网络学院92790 】

上一篇：XML转Excel最简单的方法是什么零基础也能看懂的图文教程

下一篇：Golang如何在容器中实现日志集中收集_Golang容器日志集中管理实践

首页

关于我们

产品展示

咨询研究

新闻中心

留言板

联系我们

新闻中心 NEWS CENTER

C++如何实现一个简单的AST_使用C++构建抽象语法树并进行代码解析

1. 定义AST节点基类

2. 实现具体节点类型

3. 添加变量环境支持

4. 简单的词法分析器（Tokenizer）

5. 递归下降解析器

6. 使用示例