设计模式 | 解释器模式

原创 于 2025-07-03 08:30:00 发布 · 1.1k 阅读 · 18 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#设计模式 #解释器模式

解释器模式（Interpreter Pattern）是行为型设计模式中的语言解析大师，它将语言的文法规则封装为对象，并定义一个解释器来解释语言中的句子。这种模式擅长处理特定领域语言（DSL）的解析问题，通过构建抽象语法树（AST）实现对复杂语法的灵活解释。本文将深入剖析解释器模式的核心思想、实现技巧及其在C++中的高效实践。

为什么需要解释器模式？

在软件开发中，我们常需解析特定领域语言：

  • 数学表达式计算器

  • 规则引擎的条件评估

  • SQL查询解析器

  • 正则表达式处理器

  • 编译器/解释器的语法分析

直接硬编码解析逻辑会导致：
紧耦合：业务逻辑与解析规则深度绑定
扩展困难：新增语法需修改核心解析器
维护复杂：语法规则分散在代码各处
缺乏抽象：难以复用通用解析逻辑

解释器模式通过将文法规则封装为可组合对象，优雅解决了这些问题。

解释器模式的核心概念

模式结构解析
        [客户端] 
           │
           ▼
[抽象表达式] ◄── [上下文]
     ▲      ▲
     │      │
[终结符表达式] [非终结符表达式]
关键角色定义

  1. 抽象表达式（Expression）

    • 声明解释操作的接口

    • 包含interpret方法

  2. 终结符表达式（Terminal Expression）

    • 实现与文法中终结符相关的解释操作

    • 代表语言的最小解析单元

  3. 非终结符表达式（Nonterminal Expression）

    • 每条文法规则对应一个类

    • 包含其他表达式的引用（组合模式）

  4. 上下文（Context）

    • 包含解释器需要的全局信息

    • 存储变量值等中间状态

  5. 客户端（Client）

    • 构建抽象语法树（AST）

    • 调用解释操作

C++实现：数学表达式计算器

实现支持变量、四则运算和函数的表达式解析器：

#include <iostream>
#include <memory>
#include <unordered_map>
#include <cmath>
#include <vector>
#include <stdexcept>

// ================= 上下文：存储变量值 =================
class Context {
public:
    void setVariable(const std::string& var, double value) {
        variables_[var] = value;
    }
    
    double getVariable(const std::string& var) const {
        auto it = variables_.find(var);
        if (it == variables_.end()) {
            throw std::runtime_error("未定义变量: " + var);
        }
        return it->second;
    }

private:
    std::unordered_map<std::string, double> variables_;
};

// ================= 抽象表达式接口 =================
class Expression {
public:
    virtual ~Expression() = default;
    virtual double interpret(const Context& context) const = 0;
};

// ================= 终结符表达式：数字常量 =================
class Number : public Expression {
public:
    explicit Number(double value) : value_(value) {}
    
    double interpret(const Context&) const override {
        return value_;
    }

private:
    double value_;
};

// ================= 终结符表达式：变量 =================
class Variable : public Expression {
public:
    explicit Variable(std::string name) : name_(std::move(name)) {}
    
    double interpret(const Context& context) const override {
        return context.getVariable(name_);
    }

private:
    std::string name_;
};

// ================= 非终结符表达式：二元运算 =================
class BinaryOperation : public Expression {
public:
    enum Operator { ADD, SUB, MUL, DIV, POW };

    BinaryOperation(std::unique_ptr<Expression> left, 
                    Operator op, 
                    std::unique_ptr<Expression> right)
        : left_(std::move(left)), op_(op), right_(std::move(right)) {}
    
    double interpret(const Context& context) const override {
        double leftVal = left_->interpret(context);
        double rightVal = right_->interpret(context);
        
        switch (op_) {
            case ADD: return leftVal + rightVal;
            case SUB: return leftVal - rightVal;
            case MUL: return leftVal * rightVal;
            case DIV: 
                if (rightVal == 0) throw std::runtime_error("除零错误");
                return leftVal / rightVal;
            case POW: return std::pow(leftVal, rightVal);
            default: throw std::runtime_error("未知运算符");
        }
    }

private:
    std::unique_ptr<Expression> left_;
    Operator op_;
    std::unique_ptr<Expression> right_;
};

// ================= 非终结符表达式：函数调用 =================
class FunctionCall : public Expression {
public:
    FunctionCall(std::string funcName, 
                 std::vector<std::unique_ptr<Expression>> args)
        : funcName_(std::move(funcName)), args_(std::move(args)) {}
    
    double interpret(const Context& context) const override {
        if (funcName_ == "sqrt") {
            validateArgCount(1);
            double arg = args_[0]->interpret(context);
            if (arg < 0) throw std::runtime_error("sqrt参数不能为负");
            return std::sqrt(arg);
        }
        if (funcName_ == "max") {
            validateArgCount(2);
            double a = args_[0]->interpret(context);
            double b = args_[1]->interpret(context);
            return std::max(a, b);
        }
        throw std::runtime_error("未知函数: " + funcName_);
    }

private:
    void validateArgCount(size_t expected) const {
        if (args_.size() != expected) {
            throw std::runtime_error(funcName_ + "需要" + 
                std::to_string(expected) + "个参数");
        }
    }
    
    std::string funcName_;
    std::vector<std::unique_ptr<Expression>> args_;
};

// ================= 表达式构建器（简化AST创建） =================
class ExpressionBuilder {
public:
    static std::unique_ptr<Expression> number(double value) {
        return std::make_unique<Number>(value);
    }
    
    static std::unique_ptr<Expression> variable(const std::string& name) {
        return std::make_unique<Variable>(name);
    }
    
    static std::unique_ptr<Expression> add(
        std::unique_ptr<Expression> left,
        std::unique_ptr<Expression> right) {
        return std::make_unique<BinaryOperation>(
            std::move(left), BinaryOperation::ADD, std::move(right));
    }
    
    static std::unique_ptr<Expression> mul(
        std::unique_ptr<Expression> left,
        std::unique_ptr<Expression> right) {
        return std::make_unique<BinaryOperation>(
            std::move(left), BinaryOperation::MUL, std::move(right));
    }
    
    static std::unique_ptr<Expression> func(
        const std::string& name,
        std::vector<std::unique_ptr<Expression>> args) {
        return std::make_unique<FunctionCall>(name, std::move(args));
    }
};

// ================= 客户端代码 =================
int main() {
    Context context;
    context.setVariable("x", 3.0);
    context.setVariable("y", 4.0);
    
    // 构建表达式: sqrt(x^2 + y^2)
    auto expr = ExpressionBuilder::func("sqrt", {
        ExpressionBuilder::add(
            ExpressionBuilder::mul(
                ExpressionBuilder::variable("x"),
                ExpressionBuilder::variable("x")
            ),
            ExpressionBuilder::mul(
                ExpressionBuilder::variable("y"),
                ExpressionBuilder::variable("y")
            )
        )
    });
    
    try {
        double result = expr->interpret(context);
        std::cout << "计算结果: " << result << std::endl;  // 输出5.0
    } catch (const std::exception& e) {
        std::cerr << "计算错误: " << e.what() << std::endl;
    }
    
    // 构建表达式: max(2*(3+4), 15)
    auto expr2 = ExpressionBuilder::func("max", {
        ExpressionBuilder::mul(
            ExpressionBuilder::number(2),
            ExpressionBuilder::add(
                ExpressionBuilder::number(3),
                ExpressionBuilder::number(4)
            )
        ),
        ExpressionBuilder::number(15)
    });
    
    std::cout << "max(2*(3+4), 15) = " 
              << expr2->interpret(context) << std::endl;  // 输出15
    
    return 0;
}

解释器模式的五大优势

  1. 语法扩展灵活

    // 新增函数只需扩展FunctionCall
class FunctionCall : public Expression {
    // ...
    if (funcName_ == "sin") 
        return sin(args[0]->interpret(context));
};

  2. 文法规则对象化

    // 每条规则对应独立类
class PowerOperation : public BinaryOperation {
    // 专门处理幂运算规则
};

  3. 易于实现复杂解析逻辑

    // 组合模式构建AST
auto expr = add(mul(var("x"), var("x")), 
              mul(var("y"), var("y")));

  4. 支持多种解释方式

    // 同一表达式不同解释
double numericResult = expr->interpret(context);
string sql = expr->toSQL(); // 可扩展为SQL生成

  5. 分离语法与业务逻辑

    // 业务代码不依赖具体语法
double calculate(Expression& expr) {
    return expr.interpret(context);
}

解释器模式的高级应用

1. 结合访问者模式遍历AST
class ExpressionVisitor {
public:
    virtual void visit(Number&) = 0;
    virtual void visit(Variable&) = 0;
    virtual void visit(BinaryOperation&) = 0;
};

class ASTPrinter : public ExpressionVisitor {
    void visit(Number& num) override {
        std::cout << num.value();
    }
    void visit(Variable& var) override {
        std::cout << var.name();
    }
    void visit(BinaryOperation& op) override {
        std::cout << "(";
        op.left().accept(*this);
        std::cout << op.symbol();
        op.right().accept(*this);
        std::cout << ")";
    }
};

// 表达式基类添加accept方法
class Expression {
public:
    virtual void accept(ExpressionVisitor& visitor) = 0;
};
2. 错误处理与恢复
class SafeInterpreter {
public:
    double interpret(const Expression& expr) {
        try {
            return expr.interpret(context_);
        } catch (const std::exception& e) {
            logError(e.what());
            recover();
            return std::numeric_limits<double>::quiet_NaN();
        }
    }
    
private:
    void recover() {
        // 恢复上下文到安全状态
    }
};
3. 语法树持久化
class ExpressionSerializer {
public:
    std::string serialize(const Expression& expr) {
        expr.serialize(*this);
        return stream_.str();
    }
    
    void visit(Number& num) {
        stream_ << "Number:" << num.value();
    }
    
    void visit(Variable& var) {
        stream_ << "Var:" << var.name();
    }
    
private:
    std::ostringstream stream_;
};

应用场景

1. 规则引擎条件解析
// 条件表达式：age > 25 && income > 50000
auto condition = make_and(
    make_compare(GT, make_var("age"), make_number(25)),
    make_compare(GT, make_var("income"), make_number(50000))
);

// 应用规则
Context ctx;
ctx.setVariable("age", 30);
ctx.setVariable("income", 60000);
bool qualified = condition->interpret(ctx); // true
2. SQL查询生成器
// SELECT name FROM users WHERE age > 25
auto query = make_select({"name"},
                make_from("users"),
                make_where(
                    make_compare(GT, make_col("age"), make_value(25))
                ));

std::cout << query->toSQL(); 
// 输出: SELECT name FROM users WHERE age > 25
3. 游戏脚本系统
// 游戏AI脚本
auto aiScript = make_sequence({
    make_move_to("enemy_base"),
    make_if(
        make_detect("enemy"),
        make_attack(),
        make_wait(5.0)
    ),
    make_use("skill", 3)
});

// 每帧执行
aiScript->interpret(gameContext);

解释器模式与其他模式的关系

模式关系区别
组合模式常共同构建AST组合关注结构，解释器关注行为
访问者模式遍历解释器创建的AST访问者添加新操作不修改类
享元模式共享终结符表达式减少重复对象创建
建造者模式构建复杂语法树分离AST构造与解释逻辑

组合使用示例：

// 解释器 + 访问者 + 享元
class ExpressionCache {
public:
    Expression& getVariable(const std::string& name) {
        if (!cache_.count(name)) {
            cache_[name] = std::make_unique<Variable>(name);
        }
        return *cache_[name];
    }
    
private:
    std::unordered_map<std::string, std::unique_ptr<Expression>> cache_;
};

解释器模式的挑战与解决方案

挑战解决方案
复杂文法性能低使用语法分析器生成器（如ANTLR）
维护大量表达式类结合原型模式克隆表达式对象
错误处理复杂定义精细的错误恢复策略
文法规则冲突引入规则优先级机制

轻量级文法扩展方案：

class DynamicExpression : public Expression {
public:
    using InterpFunc = std::function<double(const Context&)>;
    
    DynamicExpression(InterpFunc func) : func_(func) {}
    
    double interpret(const Context& ctx) const override {
        return func_(ctx);
    }
    
private:
    InterpFunc func_;
};

// 动态创建表达式
auto expr = std::make_shared<DynamicExpression>(
    [](const Context& ctx) {
        return ctx.get("x") * 2 + 3;
    }
);

总结

解释器模式是处理领域特定语言的终极武器，它通过：
文法对象化：将语法规则转化为类层次结构
AST构建：组合模式创建语法树
解释分离：解析逻辑独立于业务代码
灵活扩展：轻松添加新语法规则

适用场景：

  • 需要解析领域特定语言

  • 语法规则相对稳定

  • 性能不是关键瓶颈

  • 需要支持多种解释输出

"解释器模式不是简单的字符串解析，而是将语言规则提升为一等公民。它是领域特定语言通向可执行逻辑的优雅桥梁。" — 设计模式实践者

设计模式-解释器模式（Interpreter）
m0_51176516的博客
05-09 2101
解释器模式（Interpreter Pattern）是一种行为型设计模式，它用于定义一个语言的文法，并解析语言中的表达式。具体来说，解释器模式通过定义一个解释器来解释语言中的表达式，从而实现对语言的解析和执行。 在解释器模式中，语言中的每个符号都被定义为一个（对象）类，这样整个程序就被转换成一个具体的对象树。每个节点（即对象）都表示一个表达式中的一个符号，而整棵树则表示一个完整的表达式。通过遍历这棵树，解释器就可以对表达式进行解析和执行。
设计模式 16 解释器模式 Interpreter Design Pattern
jxusthusiwen的专栏
05-21 1143
解释器模式 (Interpreter Design Pattern) 是一种行为型设计模式，它定义了一种语法表示，并提供了一种解释器来解释该语法表示的句子。核心概念：语法表示 (Grammar): 定义了语言的结构和规则，通常使用上下文无关文法 (Context-Free Grammar) 来表示。解释器 (Interpreter): 一个对象，它根据语法规则解析和执行语言的句子。主要组成部分：抽象解释器 (AbstractExpression): 定义解释器的接口，包含解释方法。
解释器模式（interpreter）
无简介
05-29 3248
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。如果在一个系统中需要匹配字符的需求在软件的很多地方都会使用，而且行为之间都非常类似，过去的做法是针对特定的需求，编写特定的函数，比如判断Email、匹配电话号码等等，与其为每一个特定需求都写一个算法函数，不如使用一种通用的搜索算法来解释执行一个正则表达式，该正则表达式定义了待匹配字符串的集合。
解释器模式
Charge8的博客
12-12 993
解释器模式
设计模式第17讲——解释器模式（Interpreter）
让~学习~成为一种习惯（橡 皮 人の技术博客）
06-27 1999
一、什么是解释器模式 二、角色组成 三、优缺点 四、应用场景 4.1 生活场景 4.2 java场景 五、代码实现 5.0 UML类图 5.1 Expression——抽象表达式（Abstract Expression）5.2 终结符表达式（Terminal Expression）5.3 非终结符表达式（Nonterminal Expression）5.4 InterpreterVariables——上下文（Context）5.5 testInterpreter 六、总结
设计模式之解释器模式的魅力：让代码读懂你的语言
犬余的博客
03-30 3528
解释器模式（Interpreter pattern）是一种行为型(Behavioral Pattern)的设计模式，用于定义语言的语法规则表示，并提供解释器来处理句子中的语法。该模式将句子表示为一个抽象语法树，每个节点代表一个语法规则，通过递归地解释这些节点来实现对句子的解释。
设计模式 解释器模式（Interpreter Pattern）
最新发布
ling_zhi_xin的博客
09-09 1957
解释器模式（Interpreter Pattern）是一种软件设计模式，属于行为型模式之一。这种模式的主要目的是定义语言的语法表示，并且提供了一个解释器来处理这种表示。解释器模式可以用于解析语言或表达式等场合，特别是在编译器、解释器和自然语言处理中应用较多。解释器模式包含以下几个主要角色： Abstract Expression 创建接口方法 Terminal Expression 对数据简单处理 Terminal Expression 是解释器模式中的一种表达式类型，它表示文法中的最基本元素，这些元素不
23种设计模式之解释器模式（Interpreter Pattern）
热门推荐
小威的博客
05-26 2万+
本篇文章将23种设计模式中的解释器模式，此篇文章为一天学习一个设计模式系列文章，后面会分享其他模式知识。
设计模式之解释器模式（Interpreter Pattern）
猎人在吃肉
03-22 605
文章目录一、定义二、应用场景三、优缺点3.1、优点：3.2、缺点：3.3、 使用场景3.4、. 应用实例3.5、 注意事项四、UML类图4.1、主要角色4.2、UML类图4.3、 典型代码4.3.1、AbstractExpression 抽象表达式类，典型代码：4.3.2、TerminalExpression 终结符表达式，典型代码：4.3.3、NonterminalExpression 非终结...
设计模式-解释器模式-Interpreter Pattern
wesigj的博客
09-09 1606
解释器模式（Interpreter Pattern）是一种行为设计模式，它主要用于定义如何评估语言的语法或表达式，是一种用于解释执行语言的模式。这种模式涉及到创建一个表达式接口，该接口能够解释一个特定的上下文。解释器模式通常用于解析和执行语言的语法规则，如计算表达式、解析文本文件等。抽象表达式（AbstractExpression）：终结符表达式（TerminalExpression）：非终结符表达式（NonterminalExpression）：上下文（Context）：客户端（Client）：需要解释一
设计模式——解释器模式
meser88的博客
06-21 622
解释器模式，就是定义语言的文法，并建立一个解释器来解释该语言中的句子，通过构建解释器，解决某一频繁发生的特定类型问题实例。这里我们将语言理解成使用规定格式和语法的代码解释器模式描述了如何构成一个简单的语言解释器，主要应用在使用面向对象语言开发的编译器中，它描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。例如我们经常利用正则表达式检测某些字符串是否符合我们规定的格式。
设计模式行为型——解释器模式
tszc95的博客
08-02 773
解释器模式（Interpreter Pattern）属于行为型模式，其提供了评估语言的语法或表达式的方式。给定一个语言，解释器模式可以定义出其文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。解释器中涉及到的文法，就是符合一定规则的语句结构.其实质是把语言中的每个符号定义成一个（对象）类，从而把每个程序转换成一个具体的对象树。
设计模式之【解释器模式】，用语言定义一门语言
秃了也弱了
05-24 1384
解释器模式（Interpreter Pattern）是指给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。是一种按照规定的语法（文法）进行解析的模式，属于行为型模式。就比如编译器可以将源码编译解释为机器码，让CPU能进行识别并运行。解释器模式的作用其实与编译器一样，都是将一些固定的文法（即语法）进行解释，构建出一个解释句子的解释器。
设计模式之解释器模式
程序员田同学的博客
09-06 3059
解释器模式字面意思，也即解释某些内容的含义。这种设计模式是实际开发中最不容易用到的。比如SQL解析，符号处理引擎，会用到解释器模式，属于更底层的开发人员才会用到的设计模式。本文就以解释器模式的概念、角色和简单的例子说明解释器模式，读者对这部分内容了解即可。
解释器模式(Interpreter)
Go的全部
01-22 655
解释器模式(Interpreter) 1.意图 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 2.适用性 当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好： 该文法简单对于复杂的文法,文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。它们无需构建抽象语法树即可解释表达式,这样可以节省空间而且还可能节省时间。 效率不是一个关键问题最高效的解释器通常不是通
设计模式（20）——解释器模式
minge0001的博客
05-12 707
目录四则运算问题传统方法解决四则运算问题分析解释器模式解释器模式来实现四则解释器模式在Spring框架应用的源码剖析解释器模式的注意事项和细节 四则运算问题 通过解释器模式来实现四则运算，如计算a+b-c的值，具体要求 先输入表达式的形式，比如a+b+c-d+e，要求表达式的字母不能重复 在分别输入a,b,c,d,e 的值 最后求出结果：如图 传统方法解决四则运算问题分析 编写一个方法，接...
解释器（interpreter） in Java
可口可乐的博客
12-18 709
定义：解释器模式是一种按照规定语法进行解析的方案，在现在项目中使用较少。正式定义：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语句中的句子。 解释器模式有以下几个角色： AbstractExpression抽象解释器 具体的解释任务由各个实现类完成。TerminalExpression终结符表达式 实现与文法中的元素相关联的解释操作，通常一个解释
深入浅出设计模式 - 解释器模式
激流丶的博客
06-29 4251
深入浅出设计模式 - 解释器模式
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值