解释器模式_行为型

解释器模式_行为型_GOF23

news2025/4/2 0:15:44

解释器模式

解释器模式（Interpreter Pattern）是一种行为型设计模式，核心思想是定义语言的文法规则，并构建一个解释器来解析和执行该语言中的表达式。它类似于“翻译器”——将符合特定语法规则的文本（如数学公式、脚本指令）转换为可执行的逻辑或计算结果，而无需直接硬编码解析逻辑。

一、通俗理解

假设你开发一个计算器程序：

传统方式：直接解析 "3+4*2" 字符串，需处理运算符优先级、括号嵌套等复杂逻辑，代码臃肿且难以扩展。
解释器模式：
- 表达式类（如 Add、Multiply）表示文法规则，每个类封装一个操作。
- 解释器将表达式字符串解析为树形结构（如 3 + (4 * 2)），递归调用各节点计算最终结果。
  这样新增运算符（如指数运算）只需添加新表达式类，无需修改核心逻辑。

二、模式结构

解释器模式包含以下角色：

抽象表达式（Expression）：定义 interpret() 接口，声明解释操作。
终结符表达式（TerminalExpression）：处理语法中的基础元素（如数字、变量）。
非终结符表达式（NonTerminalExpression）：处理组合结构（如运算符、逻辑语句），通常包含其他表达式对象。
上下文（Context）：存储解释过程中需要的全局信息（如变量值）。
客户端（Client）：构建表达式树并触发解释过程。

三、适用场景

数学表达式求值：如计算器、公式引擎。
领域特定语言（DSL）：如游戏脚本、配置文件解析。
规则引擎：如业务规则判断（如 "年龄>18 && 信用分>60"）。
简单语法解析：如正则表达式、SQL条件子句。

不适用场景：

语法过于复杂（如完整编程语言），此时需专业解析工具（如ANTLR）。
对性能要求极高，因递归解释可能导致效率问题。

四、代码实现

1. C++ 示例（数学表达式求值）

#include <iostream>  
#include <map>  
#include <string>  

// 抽象表达式  
class Expression {  
public:  
    virtual int interpret(const std::map<std::string, int>& context) = 0;  
    virtual ~Expression() = default;  
};  

// 终结符表达式：数字  
class Number : public Expression {  
    int value;  
public:  
    Number(int v) : value(v) {}  
    int interpret(const std::map<std::string, int>&) override { return value; }  
};  

// 非终结符表达式：加法  
class Add : public Expression {  
    Expression* left;  
    Expression* right;  
public:  
    Add(Expression* l, Expression* r) : left(l), right(r) {}  
    int interpret(const std::map<std::string, int>& ctx) override {  
        return left->interpret(ctx) + right->interpret(ctx);  
    }  
    ~Add() { delete left; delete right; }  
};  

// 客户端  
int main() {  
    // 表达式：2 + (3 + 5)  
    Expression* expr = new Add(new Number(2), new Add(new Number(3), new Number(5)));  
    std::map<std::string, int> context;  // 本例未使用变量  
    std::cout << "结果: " << expr->interpret(context);  // 输出：10  
    delete expr;  
    return 0;  
}

解析：

Add 组合左右表达式，递归计算值。
扩展减法只需新增 Subtract 类。

2. Python 示例（逻辑条件判断）

from abc import ABC, abstractmethod  

class Expression(ABC):  
    @abstractmethod  
    def interpret(self, context):  
        pass  

# 终结符：变量值  
class Variable(Expression):  
    def __init__(self, name):  
        self.name = name  
    def interpret(self, context):  
        return context.get(self.name, False)  

# 非终结符：逻辑或  
class Or(Expression):  
    def __init__(self, expr1, expr2):  
        self.expr1 = expr1  
        self.expr2 = expr2  
    def interpret(self, context):  
        return self.expr1.interpret(context) or self.expr2.interpret(context)  

# 客户端  
context = {"A": True, "B": False}  
expr = Or(Variable("A"), Variable("B"))  
print(expr.interpret(context))  # 输出：True

特点：

支持动态条件组合（如 A || (C && D)）。

3. Java 示例（四则运算解析器）

import java.util.Stack;  

// 抽象表达式  
interface Expression {  
    int interpret();  
}  

// 终结符：数字  
class Number implements Expression {  
    private int value;  
    public Number(int v) { this.value = v; }  
    public int interpret() { return value; }  
}  

// 非终结符：加法  
class Add implements Expression {  
    private Expression left, right;  
    public Add(Expression l, Expression r) {  
        this.left = l;  
        this.right = r;  
    }  
    public int interpret() {  
        return left.interpret() + right.interpret();  
    }  
}  

// 客户端构建表达式树  
public class Client {  
    public static void main(String[] args) {  
        // 表达式： (5 + 3) - (2 * 4)  
        Expression expr = new Subtract(  
            new Add(new Number(5), new Number(3)),  
            new Multiply(new Number(2), new Number(4))  
        );  
        System.out.println("结果: " + expr.interpret());  // 输出：8 - 8 = 0  
    }  
}

扩展性：

新增 Multiply、Divide 类即可支持更多运算符。

五、优缺点分析

优点	缺点
1. 灵活扩展语法：新增规则只需添加类	1. 类膨胀：每个语法规则对应一个类
2. 解耦解析与执行：逻辑清晰易维护	2. 性能瓶颈：递归解释效率较低
3. 支持复杂表达式：树形结构处理嵌套逻辑	3. 不适合复杂文法：需专业解析工具