C++设计模式——Interpreter解释器模式

于 2024-09-12 00:15:00 发布
阅读量618 收藏 8
点赞数 29
分类专栏： C++设计模式 文章标签： 设计模式 解释器模式 c++ c语言 开发语言 linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CoderZZ_2024/article/details/142033558
版权

一，解释器模式的定义

解释器模式是一种行为型设计模式，它用于定义一个语言的文法并解析语言中的表达式，使开发者可以实现自定义语言，并通过解释器对语言中的表达式进行解析和执行。

解释器模式主要用于解决对特定表达式的解析与执行，它定义了一种解释器的语法规则，通过解释器来解析并执行自定义的语言表达式。

通过解释器，可以将复杂的语言解析问题拆分为简单的表达式解析，并且可以通过增加新的解释器对象来扩展语言的功能。

解释器模式在现实生活中的抽象实例：

自然语言解释器：比如翻译软件，可以将一种语言的句子解释为另一种语言。

数学表达式解析器：计算机程序中的数学表达式可以由解析器解释和计算。

正则表达式解析器：正则表达式是一种用于描述字符串模式的语言，正则表达式解析器可以解析正则表达式。

指令解释器：计算机程序中的指令集可以由解释器解释和执行，将指令转换为对计算机底层的操作。

二，解释器模式的结构

解释器模式主要包含以下组件：

1.抽象表达式(Abstract Expression)：

定义解释器的接口，声明抽象的解释方法interpret()。

2.终结符表达式(Terminal Expression)：

实现抽象表达式的interpret()方法，用于解析语言中的终结符表达式。

3.非终结符表达式(Nonterminal Expression)：

实现抽象表达式的interpret()方法，用于解析语言中的非终结符表达式。非终结符表达式通常由多个终结符表达式组成，可以通过递归的方式进行解析。

4.上下文(Context)：

包含解释器需要解析的数据，用于存储需要被解释器解析的上下文信息。

5.客户端(Client)：

负责创建抽象表达式及具体表达式对象，并调用解释方法进行解析。

在解释器的工作过程中，从输入语言文本开始，解析器首先识别出终结符，然后递归处理它们之间的嵌套结构，直到整个语言表达式都被处理完毕。

解释器模式的关键成分：

终结符表达式(Terminal Expression)：

终结符表达式是语法中的基本单元，它们通常是程序的最原子的成分，如数字、关键字、标识符等。终结符表达式的处理相对简单，通常由解释器直接处理并返回结果，在编码实现中，它们对应于语法解析树中的叶子节点。

非终结符表达式(Non-Terminal Expression)：

非终结符表达式则代表了更复杂的语法结构，比如判断条件、循环等，它是通过组合其他终结符和非终结符构建而成的。非终结符表达式在解释器模式中通常映射到具体的抽象类或接口，其作用是在适当的时候递归地调用解析器去处理它的组成成分。当遇到非终结符时，解释器会创建一个新的实例，并调用对应的解析方法，这个方法会根据上下文做进一步的解析。

组件之间的工作步骤如下：

1.客户端创建上下文对象，并将待解析的语言表达式传入到上下文。

2.客户端创建终结符表达式和非终结符表达式对象，并根据解释器语法规则将它们组合成一个语法解析树。

3.客户端调用解释器的interpret()方法，依次对每个终结符和非终结符进行解释和执行。

4.解释器根据具体的语法规则对语言表达式进行解析，并执行相应的操作。

5.整个执行流程中，解释器可以将解析得到的值存储在上下文中，以供后续的解析使用。

对应UML类图：

三，解释器模式代码样例

Demo1：解析数学表达式

#include <iostream>
#include <string>
#include <stack>
#include <sstream>

class Expression {
public:
    virtual int interpret() = 0;
};

class NumberExpression : public Expression {
public:
    NumberExpression(int number) : m_number(number) {}
    int interpret() override {
        return m_number;
    }
private:
    int m_number;
};

class AddExpression : public Expression {
public:
    AddExpression(Expression* left, Expression* right)
        : m_left(left), m_right(right) {}
    int interpret() override {
        return m_left->interpret() + m_right->interpret();
    }
private:
    Expression* m_left;
    Expression* m_right;
};

class Context {
public:
    Expression* evaluate(const std::string& expression) {
        std::stack<Expression*> stack;
        std::stringstream ss(expression);
        std::string token;
        while (getline(ss, token, ' ')) {
            if (token == "+") {
                Expression* right = stack.top();
                stack.pop();
                Expression* left = stack.top();
                stack.pop();
                Expression* addExp = new AddExpression(left, right);
                stack.push(addExp);
            }
            else {
                int number = stoi(token);
                Expression* numberExp = new NumberExpression(number);
                stack.push(numberExp);
            }
        }
        return stack.top();
    }
};

int main() {
    Context context;

    Expression* expression = context.evaluate("2 3 +");
    int result = expression->interpret();
    std::cout << "Result: " << result << std::endl;

    delete expression;
    return 0;
}

运行结果：

Result: 5

Demo2：解析字符串

#include <iostream>
#include <string>
#include <vector>

class Expression {
public:
    virtual bool interpret(const std::string& context) = 0;
};

class TerminalExpression : public Expression{
private:
    std::string expression;
public:
    TerminalExpression(const std::string& expression) : expression(expression) {}
    bool interpret(const std::string& context) override {
        if (context.find(expression) != std::string::npos) {
            return true;
        }
        return false;
    }
};

class OrExpression: public Expression {
private:
    Expression* expr1;
    Expression* expr2;
public:
    OrExpression(Expression* expr1, Expression* expr2)
        : expr1(expr1), expr2(expr2) {}
    bool interpret(const std::string& context) override {
        return expr1->interpret(context) || expr2->interpret(context);
    }
};

int main() {
    Expression* expr1 = new TerminalExpression("hello");
    Expression* expr2 = new TerminalExpression("world");
    Expression* orExpr = new OrExpression(expr1, expr2);

    std::vector<std::string> contexts = { "hello", "world", "hello world", "hi" };

    for (const auto& context: contexts) {
        if (orExpr->interpret(context)) {
            std::cout << "Expression is true for context: " << context << std::endl;
        }
        else {
            std::cout << "Expression is false for context: " << context << std::endl;
        }
    }

    delete expr1;
    delete expr2;
    delete orExpr;
    return 0;
}

运行结果：

Expression is true for context: hello
Expression is true for context: world
Expression is true for context: hello world
Expression is false for context: hi

四，解释器模式的应用场景

脚本解析器：如JavaScript、Python等动态语言中，解释器模式用于读取源码并逐行解释执行，不需要预先编译。

数据处理：在数据分析或科学计算库(如NumPy)中，可以使用解释器模式处理复杂的数学表达式。

命令行工具：许多命令行工具会采用解释器模式来解析用户输入的命令及其参数，然后执行相应的操作。

特定描述语言(DSL)：比如SQL解析器，将SQL语句转换为数据库操作指令。

五，解释器模式的优缺点

解释器模式的优点：

灵活可扩展，解释器可以动态地添加新的语言规则，这使得系统对新语言或方言的变化更具适应性。

结构清晰，通过一步步执行解析过程，帮助开发者理解并调试。

解释器模式将语法解析和业务逻辑分离，可独立维护。

解释器模式的缺点：

性能开销大，同为语法解析，解释器通常比编译器生成的机器码运行速度慢。

当需要处理高级语法时，代码复杂度很高。

可能会包含重复计算的场景，容易消耗系统资源。

六，代码实战

Demo1：模拟的科学计算库

#include <iostream>
#include <string>

class Expression {
public:
    virtual double evaluate() = 0;
};

class Addition: public Expression {
private:
    double left;
    double right;
public:
    Addition(double l, double r) : left(l), right(r) {}
    double evaluate() override { return left + right; }
};

class Subtraction: public Expression {
private:
    double left;
    double right;
public:
    Subtraction(double l, double r) : left(l), right(r) {}
    double evaluate() override { return left - right; }
};

class Interpreter {
private:
    Expression* expr;
public:
    Interpreter(Expression* e) : expr(e) {}
    double interpret() {
        return expr->evaluate();
    }
};

int main() {
    Expression* addExpr = new Addition(3.0, 5.0);
    Expression* subExpr = new Subtraction(10.0, 7.0);

    Interpreter intp(addExpr);
    std::cout << "Addition result: "<< intp.interpret() << std::endl;
    Interpreter intp2(subExpr);
    std::cout << "Subtraction result: "<< intp2.interpret() << std::endl;

    delete addExpr;
    delete subExpr;
    return 0;
}

运行结果：

Addition result: 8
Subtraction result: 3

Demo2：模拟的汇编语言解析器

#include <iostream>
#include <string>
#include <unordered_map>

class Instruction {
public:
    virtual void execute() const = 0;
};

class LoadInstruction: public Instruction {
private:
    int value;
public:
    LoadInstruction(int v): value(v) {}
    void execute() const override {
        std::cout << "Loading value: " << value << std::endl;
    }
};

class StoreInstruction: public Instruction {
private:
    int address;
public:
    StoreInstruction(int addr) : address(addr) {}
    void execute() const override {
        std::cout << "Storing at address: " << address << std::endl;
    }
};

class Interpreter {
private:
    std::vector<Instruction*> instructions;
public:
    void addInstruction(Instruction* instr) {
        instructions.push_back(instr);
    }
    void interpret() {
        for (auto& instr : instructions) {
            instr->execute();
        }
    }
};

int main() {
    Interpreter interpreter;

    LoadInstruction loadInstr(5);
    StoreInstruction storeInstr(10);

    interpreter.addInstruction(&loadInstr);
    interpreter.addInstruction(&storeInstr);

    interpreter.interpret();
    return 0;
}

运行结果：

Loading value: 5
Storing at address: 10

Demo3：模拟的shell脚本解析器

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

class Command {
public:
    virtual ~Command() {}
    virtual void execute() = 0;
};

class CDCommand: public Command {
private:
    std::string directory;
public:
    CDCommand(const std::string& dir) : directory(dir) {}
    void execute() override {
        std::cout << "Changing directory to " << directory << std::endl;
    }
};

class LSCommand: public Command {
public:
    void execute() override {
        std::cout << "Listing files in current directory\n";
    }
};

class EchoCommand: public Command {
private:
    std::string message;
public:
    EchoCommand(const std::string& msg) : message(msg) {}
    void execute() override {
        std::cout << "Echoing: " << message << "\n";
    }
};

class Interpreter {
private:
    std::map<std::string, Command*> command_map;
public:
    void add_command(const std::string& name, Command* cmd) {
        command_map[name] = cmd;
    }
    void interpret(const std::string& cmd_str) {
        if (command_map.find(cmd_str) != command_map.end()) {
            command_map[cmd_str]->execute();
        }
        else {
            std::cerr << "Unknown command: " << cmd_str << '\n';
        }
    }
};

int main() {
    Interpreter interpreter;

    interpreter.add_command("cd", new CDCommand("/path/to/directory"));
    interpreter.add_command("ls", new LSCommand());
    interpreter.add_command("echo", new EchoCommand("Hello, World!"));

    interpreter.interpret("cd /home");
    interpreter.interpret("ls");      
    interpreter.interpret("echo hi");  

    return 0;
}

运行结果：

Unknown command: cd /home
Listing files in current directory
Unknown command: echo hi

七，参考阅读

https://blog.gmem.cc/interpreter-pattern

https://www.geeksforgeeks.org/interpreter-design-pattern/

https://www.tutorialspoint.com/design_pattern/interpreter_pattern.html

https://incusdata.com/blog/design-patterns-interpreter-pattern-part1

https://sourcemaking.com/design_patterns/interpreter/cpp/

https://mcturra2000.wordpress.com/2017/08/24/a-simple-basic-interpreter-in-c/

程序员与背包客_CoderZ
关注
  • 29
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++设计模式——解释器模式（Interpreter）
萧海的博客
08-15 360
解释器模式 在软件构建中，若某一特定领域的问题比较复杂，类似的结果不断重复出现，使用普通的编程方式来实现的话面临非常频繁的重复操作。 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。 #include <iostream> #include <map> #include <stack> using namespace std; class Expression { public: virtual int
C++设计模式——解释器模式（interpreter pattern）
净无邪博客
11-29 1369
一、原理讲解 1.1意图 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 1.2应用场景 文法简单。对于复杂的文法，文法的类层次变得庞大而无法管理；此时语法分析程序生成器这样的工具是更好的选择。它们无法构件抽象语法树即可解释表达式，这样可以节省空间而且还可能节省时间。 效率不是关键问题。最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下，转换器也可用解释器模式实现，该模
【Interpreter模式】C++设计模式——解析器
不负AC不负卿的博客
08-12 1092
C++解析器模式，Interpreter模式，本文以通俗易懂的举例帮助读者了解解析器，同时对解析器模式进行总结
【设计模式】——解释器模式（Interpreter Pattern）
J^T的博客
08-07 732
解释器模式（Interpreter Pattern）是一种行为型设计模式，它提供了一种解释语言句子或表达式的方法。这种模式特别适合需要评估复杂语法或表达式的场景，如编译器、公式解析器、查询处理系统等。本文将详细介绍解释器模式的概念、结构，并通过C++实现一个简单的算术表达式解释器。
22行为型设计模式——解释器模式
qq_55610255的博客
08-31 470
解释器模式允许你可以将复杂的语句表达式转换成对应的执行代码。这种模式通常用于字符串解析或语言解释器中。它将算术或逻辑表达式设计成一个接一个的独立的“组件”，每个组件负责解释其中一个语法符号的含义。这些组件可以单独构建、组合或重用。
设计模式【23】——解释器模式（Interpreter模式）
sinat_42974726的博客
12-09 427
一些应用提供了内建（Build-In）的脚本或者宏语言来让用户可以定义他们能够在系统中进行的操作。Interpreter模式的目的就是使用一个解释器为用户提供一个一门定义语言的语法表示的解释器，然后通过解释器来解释语言中的句子。Interpreter模式提供了一个实现语法解释器的框架。如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。
C++设计模式总结——思维导图
zhangchuan7758的博客
10-24 641
本文主要对C++设计模式进行简单介绍，后续会逐一进行剖析
Windows环境下实现设计模式——解释器模式（JAVA版）
荔园微风的博客
04-12 684
Windows环境下实现设计模式——解释器模式（JAVA版）
c++设计模式GoF23
10-28
### c++设计模式GoF23 #### 0. 引言 - **设计模式的重要性**：“Next to My Life, Software Is My Passion”——Robert C. Martin 的名言揭示了软件设计的重要地位。掌握设计模式意味着理解面向对象分析与设计...
设计模式C++版
06-13
11. Interpreter模式，解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 文档在最后提出了设计模式在开发中的体验，讨论了设计模式的思考和应用。...
设计模式-行为型模式-状态模式
LB_bei的博客
09-06 892
允许一个对象在其内部状态改变时改变他的行为，用于解决系统中复杂对象的状态转换以及不同状态下行为的封装问题，状态模式将一个对象的状态从该对象中分离出来，封装到专门的状态类中，使得对象的状态可以灵活变化；
漫谈设计模式 [11]：代理模式
刘炫320的博客
09-07 1278
老鸟：想象一下，你有一个朋友非常忙，你需要通过他的秘书与他联系。这个秘书就是你的代理，他可以帮你处理一些简单的事情，比如预约时间、传递信息等。这样，你的朋友就可以专注于他的重要工作。这就是代理模式的基本思想：通过代理对象来控制对实际对象的访问。菜鸟：哦，我明白了。代理对象就像是中间人，帮我们处理一些额外的事务。老鸟：没错。代理模式的核心思想就是在不改变原有对象的情况下，通过代理对象来添加额外的功能。老鸟：今天我们讨论了代理模式的核心思想、实现方法、优势以及适用场景。希望你能在实际项目中灵活应用。
24下半年学习计划
2301_80336512的博客
09-08 1311
上课的时候认真听，不要以为提前了解一些知识就认为不重要，不听也要坚持看书，不要被外界吸引。我以后大概率走后端方向，对于后端的一些技术栈目前只是跟着网上的教程学，网上的教程大部分。只适合入门，对其原理背后的实行的机制还是需要看一些经典书籍，因此在这一学期除了完成实验。《设计模式之美》，提高自己编写代码的规范性，了解设计原理，养成良好的写代码习惯。，数据库对于后端开发者来说十分重要，这一部分知识要熟悉掌握。早睡早起，少熬夜，最好是每天早晨记10个单词，晚上睡前复习。
MVC设计模式与delegate,tablview，Appdelegate,SceneDelegate
M3151549808的博客
09-08 665
tableView.dataSource=self 设置了UITableView的数据源为当前视图控制器对象 tableView.delegate=self 表格视图的代理对象为当前的视图控制器 那么代理有什么用呢？ 代理可以让两个视图关联起来，例如 现有两个视图控制器AVC与BVC,你要通过B视图控制器同时修改A，B两个view的背景颜色
最佳实践-模板设计模式
2303_80050865的博客
09-08 502
1）设计模式是在大量的实践中总结和理论化之后优选的代码结构、编程风格、以及解决问题的思考方式2）设计模式就像经典的棋谱，不同的棋局，我们用不同的棋谱，免去我们再思考和摸索1、基本介绍抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展、改造，但子类总体上会保留抽象类的行为方式2、模板设计模式能解决的问题1）当功能内部一部分实现是确定的，一部分是不确定的，这时可以把不确定的部分暴露出去，让子类去实现。
漫谈设计模式 [15]：观察者模式
刘炫320的博客
09-07 559
老鸟：我们先从生活中的例子聊起吧。假设你是个新闻记者，每当有重大新闻发生时，你需要通知各种媒体平台，比如电视、电台、报纸等。每次你都得一个一个通知，感觉很麻烦吧？菜鸟：是啊，如果能一次通知所有人就好了。老鸟：没错，这就是观察者模式的核心思想。你可以把自己看作"被观察者"（Subject），而那些需要通知的媒体平台看作"观察者"（Observer）。当有新闻发生时，你只需要告诉所有观察者，他们自己会去更新。老鸟：今天我们聊了观察者模式，主要解决了同步更新的问题，核心是解耦和易于扩展。
结构者设计模式
最新发布
m0_68570169的博客
09-10 993
结构者模式帮助我们以不同的方式组织和构建系统中的类和对象，从而提高系统的灵活性和可维护性。通过合理选择和应用这些模式，可以有效地管理和扩展系统的复杂性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值