解释器模式通过将语法规则映射为C++类，构建抽象语法树（AST）来解析和执行DSL或表达式。核心是Expression基类及其interpret()方法，结合Context存储变量状态，终结符（如数字、变量）和非终结符（如加减）表达式分别实现具体逻辑。适用于自定义脚本、规则引擎、配置解析等场景，优势在于语法扩展灵活、代码清晰；但语法复杂时维护成本高，性能较低。处理操作符优先级需引入独立解析器，常用递归下降法构建正确AST。当语法复杂或性能敏感时，应考虑ANTLR等生成器或编译方案替代。
C++中的解释器模式，在我看来，它提供了一种非常优雅且富有表现力的方式来解析和执行特定领域的语言（DSL）或者复杂的表达式。它不是一个包治百病的银弹，但对于那些需要动态处理语法规则，并且语法结构相对稳定的场景，它能让你的代码变得异常清晰和可扩展。
要用C++实现解释器模式来解析表达式和命令语言，核心在于将每条语法规则表示为一个类。这通常涉及构建一个抽象语法树（AST），其中每个节点都是一个表达式对象，能够解释自身。
我们通常会从一个抽象的
Expression
interpret()
Context
Context
#include <map>
#include <string>
#include <vector>
#include <iostream>
#include <memory> // For std::unique_ptr
// 上下文：存储变量及其值
class Context {
public:
void assign(const std::string& var, int value) {
variables_[var] = value;
}
int lookup(const std::string& var) const {
auto it = variables_.find(var);
if (it != variables_.end()) {
return it->second;
}
// 实际应用中可能需要抛出异常或返回特定错误码
return 0; // 简化处理，未找到变量返回0
}
private:
std::map<std::string, int> variables_;
};
// 抽象表达式
class Expression {
public:
virtual ~Expression() = default;
virtual int interpret(const Context& context) const = 0;
};
// 终结符表达式：数字
class NumberExpression : public Expression {
public:
explicit NumberExpression(int number) : number_(number) {}
int interpret(const Context& context) const override {
return number_;
}
private:
int number_;
};
// 终结符表达式：变量
class VariableExpression : public Expression {
public:
explicit VariableExpression(const std::string& name) : name_(name) {}
int interpret(const Context& context) const override {
return context.lookup(name_);
}
private:
std::string name_;
};
// 非终结符表达式：加法
class AddExpression : public Expression {
public:
AddExpression(std::unique_ptr<Expression> left, std::unique_ptr<Expression> right)
: left_(std::move(left)), right_(std::move(right)) {}
int interpret(const Context& context) const override {
return left_->interpret(context) + right_->interpret(context);
}
private:
std::unique_ptr<Expression> left_;
std::unique_ptr<Expression> right_;
};
// 非终结符表达式：减法
class SubtractExpression : public Expression {
public:
SubtractExpression(std::unique_ptr<Expression> left, std::unique_ptr<Expression> right)
: left_(std::move(left)), right_(std::move(right)) {}
int interpret(const Context& context) const override {
return left_->interpret(context) - right_->interpret(context);
}
private:
std::unique_ptr<Expression> left_;
std::unique_ptr<Expression> right_;
};
// 客户端代码示例
// 实际解析字符串并构建AST的部分通常会更复杂，这里仅为演示
// 假设我们已经有了一个AST： (a + b) - 5
/*
std::unique_ptr<Expression> ast = std::make_unique<SubtractExpression>(
std::make_unique<AddExpression>(
std::make_unique<VariableExpression>("a"),
std::make_unique<VariableExpression>("b")
),
std::make_unique<NumberExpression>(5)
);
Context context;
context.assign("a", 10);
context.assign("b", 20);
int result = ast->interpret(context); // 结果应为 (10 + 20) - 5 = 25
std::cout << "Result: " << result << std::endl;
*/这个模式的核心思想是“一即一切”：每个表达式对象都负责解释它自己那部分语法。终结符表达式（如数字、变量）直接提供值，而非终结符表达式（如加法、减法）则组合其他表达式的结果。构建AST的过程，通常需要一个单独的解析器（Parser），它读取输入的命令或表达式字符串，然后根据语法规则实例化这些
Expression
立即学习“C++免费学习笔记（深入）”；
在我看来，解释器模式最闪光的地方，莫过于它在构建那些“小而美”的自定义脚本语言或规则引擎时的表现。它特别适合处理那些领域特定的语言（DSL），这些语言的语法通常比通用编程语言简单得多，但又需要一定的灵活性和可扩展性。
想象一下，你正在开发一个游戏，需要一套简单的逻辑来定义NPC的行为或者物品的合成配方。如果用C++硬编码这些规则，每次需求变动都得改代码、编译、发布，这效率可太低了。这时候，你可以设计一套像
IF (玩家等级 > 10) AND (拥有物品 "金币" > 100) THEN 给予物品 "宝箱"
Expression
它也常用于：
但话说回来，如果你的语法规则变得异常复杂，比如要支持函数调用、循环、作用域管理，那解释器模式的直接实现可能会变得非常臃肿和难以维护。这时候，你可能就需要考虑更重量级的工具，比如词法分析器生成器（Lexer Generators，如Flex）和语法分析器生成器（Parser Generators，如Bison或ANTLR），它们能帮你自动生成解析代码，处理更复杂的语法结构。解释器模式的优势在于其手写实现的直观性和灵活性，但这种优势在面对大型复杂语法时会迅速减弱。
处理复杂的语法结构和操作符优先级确实是解释器模式面临的一大挑战，这往往是手写解析器中最容易出错的部分。我个人经验是，这需要将解析过程与解释过程明确分离，并且在解析阶段就构建一个“正确”的抽象语法树（AST）。
引入解析器（Parser）：我们不能指望
Expression
Parser
Parser
例如，对于表达式
a + b * c
a
+
b
*
c
*
+
b * c
a
递归下降解析：对于优先级和结合性，递归下降解析（Recursive Descent Parsing）是一种常用且相对直观的手写解析方法。它通过一系列递归函数来匹配语法规则，每个函数负责解析一种非终结符。优先级通常通过函数调用顺序来体现：高优先级的操作符在低优先级的操作符之前被解析。
例如，你可以有
parseExpression()
parseTerm()
parseTerm()
parseFactor()
parseFactor()
parseTerm()
parseExpression()
当
parseTerm()
parseFactor()
MultiplyExpression
DivideExpression
parseExpression()
parseTerm()
抽象语法树（AST）的构建：在解析阶段，我们的目标是生成一个能准确反映表达式语义的AST。每个
Expression
AddExpression
interpret()
interpret()
// 假设我们有一个简单的解析器骨架
class Parser {
public:
// 简化：这里直接传入tokens，实际会从字符串生成
std::unique_ptr<Expression> parse(const std::vector<std::string>& tokens) {
// ... 复杂的优先级和结合性处理逻辑
// 比如用Shunting-yard算法转换成逆波兰表达式，再构建AST
// 或者使用递归下降解析
// 这里我们手动构造一个AST来演示
// 表达式： a + b * c
// 假设 tokens 是 ["a", "+", "b", "*", "c"]
// 实际解析会复杂得多，这里直接返回一个预设的AST
return std::make_unique<AddExpression>(
std::make_unique<VariableExpression>("a"),
std::make_unique<MultiplyExpression>(
std::make_unique<VariableExpression>("b"),
std::make_unique<VariableExpression>("c")
)
);
}
};构建AST的过程是解释器模式的关键，它将文本形式的语法转换成了可供解释器直接操作的对象结构。没有一个健壮的解析器来构建正确的AST，解释器模式的
interpret()
任何设计模式都有其适用范围和局限性，解释器模式也不例外。在我看来，理解这些边界，比单纯掌握模式本身更为重要。
优点：
Expression
缺点：
Expression
何时考虑替代方案：
if/else if
std::map<std::string, std::function<...>>
Expression
以上就是C++解释器模式解析表达式与命令语言的详细内容，更多请关注php中文网其它相关文章！
每个人都需要一台速度更快、更稳定的 PC。随着时间的推移，垃圾文件、旧注册表数据和不必要的后台进程会占用资源并降低性能。幸运的是，许多工具可以让 Windows 保持平稳运行。
广告
收藏
收藏
收藏
Copyright 2014-2025 https://www.php.cn/ All Rights Reserved | php.cn | 湘ICP备2023035733号
537
