【C++】解释器模式

于 2025-06-27 09:45:03 发布
阅读量911 收藏 9
点赞数 26
CC 4.0 BY-SA版权
分类专栏： 设计模式 文章标签： c++ 解释器模式 设计模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/AAADiao/article/details/148946239

目录

解释器模式（Interpreter Pattern）是一种【行为型】设计模式，它定义了一种语言的语法表示，并提供一个解释器来解释该语言中的句子。这种模式将语言中的每个语法规则映射为一个类，使得可以通过组合这些类来解析和执行复杂的表达式。

一、模式核心概念与结构

解释器模式包含四个核心角色：

  1. 抽象表达式（Expression）：定义解释操作的接口，所有表达式类都必须实现该接口。
  2. 终结符表达式（Terminal Expression）：实现与语法中的终结符相关的解释操作，是表达式的基本构建块。
  3. 非终结符表达式（Non-terminal Expression）：包含其他表达式作为子表达式，并定义它们之间的解释关系。
  4. 上下文（Context）：包含解释器需要的全局信息，在解释过程中传递。

二、C++ 实现示例：简单算术表达式解释器

以下是一个简单的算术表达式解释器示例，支持加法和乘法：

#include <iostream>
#include <string>
#include <memory>
#include <unordered_map>
#include <vector>
#include <sstream>

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

// 终结符表达式：变量
class VariableExpression : public Expression {
private:
    std::string name;

public:
    VariableExpression(const std::string& n) : name(n) {}
    
    int interpret(const std::unordered_map<std::string, int>& context) const override {
        auto it = context.find(name);
        if (it != context.end()) {
            return it->second;
        }
        return 0;
    }
};

// 终结符表达式：常量
class ConstantExpression : public Expression {
private:
    int value;

public:
    ConstantExpression(int val) : value(val) {}
    
    int interpret(const std::unordered_map<std::string, int>& context) const override {
        return value;
    }
};

// 非终结符表达式：加法
class AddExpression : public Expression {
private:
    std::shared_ptr<Expression> left;
    std::shared_ptr<Expression> right;

public:
    AddExpression(std::shared_ptr<Expression> l, std::shared_ptr<Expression> r)
        : left(l), right(r) {}
    
    int interpret(const std::unordered_map<std::string, int>& context) const override {
        return left->interpret(context) + right->interpret(context);
    }
};

// 非终结符表达式：乘法
class MultiplyExpression : public Expression {
private:
    std::shared_ptr<Expression> left;
    std::shared_ptr<Expression> right;

public:
    MultiplyExpression(std::shared_ptr<Expression> l, std::shared_ptr<Expression> r)
        : left(l), right(r) {}
    
    int interpret(const std::unordered_map<std::string, int>& context) const override {
        return left->interpret(context) * right->interpret(context);
    }
};

// 解析器
class Parser {
public:
    static std::shared_ptr<Expression> parse(const std::string& input) {
        // 简单实现：假设输入格式为 "变量 + 变量" 或 "变量 * 变量"
        std::istringstream iss(input);
        std::string token1, op, token2;
        iss >> token1 >> op >> token2;
        
        std::shared_ptr<Expression> left, right;
        
        // 判断是变量还是常量
        if (isdigit(token1[0])) {
            left = std::make_shared<ConstantExpression>(std::stoi(token1));
        } else {
            left = std::make_shared<VariableExpression>(token1);
        }
        
        if (isdigit(token2[0])) {
            right = std::make_shared<ConstantExpression>(std::stoi(token2));
        } else {
            right = std::make_shared<VariableExpression>(token2);
        }
        
        // 根据操作符创建相应的表达式
        if (op == "+") {
            return std::make_shared<AddExpression>(left, right);
        } else if (op == "*") {
            return std::make_shared<MultiplyExpression>(left, right);
        }
        
        return nullptr;  // 无效表达式
    }
};

// 客户端代码
int main() {
    // 上下文：变量赋值
    std::unordered_map<std::string, int> context = {
        {"x", 5},
        {"y", 3}
    };
    
    // 解析并解释表达式
    std::string expr1 = "x + y";
    std::string expr2 = "x * y";
    std::string expr3 = "5 + y";
    
    auto expression1 = Parser::parse(expr1);
    auto expression2 = Parser::parse(expr2);
    auto expression3 = Parser::parse(expr3);
    
    std::cout << expr1 << " = " << expression1->interpret(context) << std::endl;
    std::cout << expr2 << " = " << expression2->interpret(context) << std::endl;
    std::cout << expr3 << " = " << expression3->interpret(context) << std::endl;
    
    return 0;
}

三、解释器模式的关键特性

  1. 语法表示：
    • 每个语法规则都被表示为一个类，便于维护和扩展。
  2. 递归解释：
    • 非终结符表达式通过递归组合其他表达式来解释复杂语句。
  3. 上下文传递：
    • 解释过程中使用上下文对象存储和传递状态信息。
  4. 扩展性：
    • 易于添加新的语法规则（表达式类），符合开闭原则。

四、应用场景

  1. 领域特定语言（DSL）：
    • 实现简单的脚本语言、配置文件解析器。
    • 例如，正则表达式引擎、SQL 查询解析器。
  2. 数学表达式计算：
    • 计算器、公式编辑器等需要解析和计算表达式的场景。
  3. 自然语言处理：
    • 简单的语义分析、关键词提取。
  4. 编译器前端：
    • 词法分析、语法分析阶段的实现。
  5. 规则引擎：
    • 解释和执行业务规则（如 IF-THEN 条件）。

五、解释器模式与其他设计模式的关系

  1. 组合模式：
    • 解释器模式通常使用组合模式来构建表达式树。
    • 非终结符表达式是组合节点，终结符表达式是叶节点。
  2. 访问者模式：
    • 可以结合访问者模式来分离解释逻辑和表达式结构。
    • 通过访问者模式可以在不修改表达式类的情况下添加新的解释操作。
  3. 状态模式：
    • 解释器的上下文可以使用状态模式来管理解释过程中的不同状态。

六、C++ 标准库中的解释器模式应用

  1. 正则表达式库：
    • std::regex是解释器模式的典型应用，将正则表达式语法解释为匹配逻辑。
  2. 字符串流：
    • std::stringstream可用于解析简单的格式化字符串。
  3. 数值转换函数：
    • std::stoi、std::stof等函数可看作是简单的解释器。

七、优缺点分析

优点：

  • 语法灵活：易于修改和扩展语法规则。
  • 可维护性：每个语法规则对应一个类，代码结构清晰。
  • 可扩展性：新增语法规则只需添加新的表达式类。

缺点：

  • 类数量膨胀：每个语法规则都需要一个类，复杂语法会导致类过多。
  • 解析效率低：递归解释可能导致性能问题，尤其对复杂语法。
  • 调试困难：表达式树的构建和解释过程可能难以理解和调试。

八、实战案例：简单 SQL 查询解释器

以下是一个简单 SQL 查询解释器的实现示例，支持 SELECT-FROM-WHERE 语句：

#include <iostream>
#include <string>
#include <memory>
#include <vector>
#include <unordered_map>
#include <regex>

// 数据模型
struct Record {
    std::unordered_map<std::string, std::string> fields;
    
    std::string get(const std::string& field) const {
        auto it = fields.find(field);
        return it != fields.end() ? it->second : "";
    }
    
    bool matches(const std::string& field, const std::string& value) const {
        return get(field) == value;
    }
};

using Table = std::vector<Record>;

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

// 终结符表达式：表名
class TableExpression : public SQLExpression {
private:
    std::string tableName;

public:
    TableExpression(const std::string& name) : tableName(name) {}
    
    Table interpret(const std::unordered_map<std::string, Table>& context) const override {
        auto it = context.find(tableName);
        if (it != context.end()) {
            return it->second;
        }
        return {};  // 空表
    }
};

// 非终结符表达式：WHERE子句
class WhereExpression : public SQLExpression {
private:
    std::shared_ptr<SQLExpression> tableExpr;
    std::string field;
    std::string value;

public:
    WhereExpression(std::shared_ptr<SQLExpression> table, 
                   const std::string& f, const std::string& v)
        : tableExpr(table), field(f), value(v) {}
    
    Table interpret(const std::unordered_map<std::string, Table>& context) const override {
        Table result;
        Table table = tableExpr->interpret(context);
        
        for (const auto& record : table) {
            if (record.matches(field, value)) {
                result.push_back(record);
            }
        }
        
        return result;
    }
};

// 非终结符表达式：SELECT子句
class SelectExpression : public SQLExpression {
private:
    std::shared_ptr<SQLExpression> tableExpr;
    std::vector<std::string> columns;

public:
    SelectExpression(std::shared_ptr<SQLExpression> table, 
                    const std::vector<std::string>& cols)
        : tableExpr(table), columns(cols) {}
    
    Table interpret(const std::unordered_map<std::string, Table>& context) const override {
        Table result;
        Table table = tableExpr->interpret(context);
        
        // 简化实现：这里只是演示，实际应只选择指定列
        return table;
    }
};

// SQL解析器
class SQLParser {
public:
    static std::shared_ptr<SQLExpression> parse(const std::string& sql) {
        // 简化实现：使用正则表达式匹配简单的SELECT-FROM-WHERE语句
        std::regex selectPattern(R"(SELECT\s+(\w+(?:,\s*\w+)*)\s+FROM\s+(\w+)(?:\s+WHERE\s+(\w+)\s*=\s*'([^']+)')?)");
        std::smatch matches;
        
        if (std::regex_search(sql, matches, selectPattern)) {
            // 提取表名
            std::string tableName = matches[2].str();
            auto tableExpr = std::make_shared<TableExpression>(tableName);
            
            // 处理WHERE子句（如果有）
            std::shared_ptr<SQLExpression> whereExpr = tableExpr;
            if (matches.size() > 3 && !matches[3].str().empty()) {
                std::string field = matches[3].str();
                std::string value = matches[4].str();
                whereExpr = std::make_shared<WhereExpression>(tableExpr, field, value);
            }
            
            // 处理SELECT子句
            std::string columnsStr = matches[1].str();
            std::vector<std::string> columns;
            std::istringstream iss(columnsStr);
            std::string column;
            
            while (std::getline(iss, column, ',')) {
                columns.push_back(column);
            }
            
            return std::make_shared<SelectExpression>(whereExpr, columns);
        }
        
        return nullptr;  // 无效SQL
    }
};

// 客户端代码
int main() {
    // 数据库上下文
    std::unordered_map<std::string, Table> database;
    
    // 创建用户表
    Table usersTable;
    usersTable.push_back({{"id", "1"}, {"name", "Alice"}, {"age", "25"}});
    usersTable.push_back({{"id", "2"}, {"name", "Bob"}, {"age", "30"}});
    usersTable.push_back({{"id", "3"}, {"name", "Charlie"}, {"age", "35"}});
    
    database["users"] = usersTable;
    
    // 解析并执行SQL查询
    std::string sql1 = "SELECT name, age FROM users";
    std::string sql2 = "SELECT * FROM users WHERE name = 'Bob'";
    
    auto expr1 = SQLParser::parse(sql1);
    auto expr2 = SQLParser::parse(sql2);
    
    // 执行查询
    Table result1 = expr1->interpret(database);
    Table result2 = expr2->interpret(database);
    
    // 输出结果
    std::cout << "Result of query 1:" << std::endl;
    for (const auto& record : result1) {
        std::cout << "Name: " << record.get("name") 
                  << ", Age: " << record.get("age") << std::endl;
    }
    
    std::cout << "\nResult of query 2:" << std::endl;
    for (const auto& record : result2) {
        std::cout << "ID: " << record.get("id") 
                  << ", Name: " << record.get("name") 
                  << ", Age: " << record.get("age") << std::endl;
    }
    
    return 0;
}

九、实现注意事项

  1. 语法复杂度：
    • 对于复杂语法，考虑使用词法分析器（如 Flex）和语法分析器（如 Bison）工具。
  2. 解释器性能：
    • 递归解释可能导致性能问题，可考虑使用编译技术（如将表达式编译为中间代码）。
  3. 错误处理：
    • 实现健壮的错误处理机制，捕获并报告语法错误。
  4. 上下文管理：
    • 设计清晰的上下文对象，避免在解释过程中传递过多参数。

解释器模式是 C++ 中实现自定义语言解释的重要工具，通过将语法规则映射为类层次结构，使系统更具灵活性和可扩展性，特别适合需要自定义表达式或简单语言解析的场景。

如果这篇文章对你有所帮助，渴望获得你的一个点赞！

在这里插入图片描述

C++ 解释器模式
xiaobeibei2的博客
08-07 415
解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。 建议当文法非常复杂时，使用其他的技术如语法分析程序或编译器来处理。
C++设计模式——Interpreter解释器模式
程序员与背包客_CoderZ
09-12 1180
解释器模式是一种行为型设计模式，它用于定义一个语言的文法并解析语言中的表达式，使开发者可以实现自定义语言，并通过解释器对语言中的表达式进行解析和执行。解释器模式主要用于解决对特定表达式的解析与执行，它定义了一种解释器的语法规则，通过解释器来解析并执行自定义的语言表达式。通过解释器，可以将复杂的语言解析问题拆分为简单的表达式解析，并且可以通过增加新的解释器对象来扩展语言的功能。自然语言解释器：比如翻译软件，可以将一种语言的句子解释为另一种语言。
设计模式：解释器模式 C++实现
DU_YULIN的博客
09-04 714
文章目录前言1. 解释器模式的理解2. 解释器模式的C++实现总结参考 前言 今天复习了解释器模式，虽然大家都说这个模式很少用到，这里也跟大家分享下，毕竟是前人总结的面向对象编程的经验啊，学习下思想也是好的。 1. 解释器模式的理解 解释器模式，个人理解，就是给出一种新的表示方式来表示想要表示的东西，比如定义一种新的编程语言来简化想要表示的东西，C/C++/Python…这些都可以理解为解释器模式，只是它们更复杂，更宽泛，大家可以把这一设计模式与Python解释器关联起来。 解释器模式比较正规的定义与类
我所理解的设计模式（C++实现）——解释器模式（Interpreter Pattern）
runfeel
07-06 282
概述： 未来机器智能化已然成为趋势，现在手机都能听懂英语和普通话，那我大中华几万种方言的被智能化也许也是趋势，我们的方言虽然和普通话相似，但是还是不一样的。这可能需要一个新的语法分析器来帮助我们。 我们的解释器模式就是描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。 但是解释一门自然语言是复杂的过程，我们以加减运算为例子来详细解释解释器模式。 ...
C++设计模式——解释器模式（interpreter pattern）
净无邪博客
11-29 1583
一、原理讲解 1.1意图 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 1.2应用场景 文法简单。对于复杂的文法，文法的类层次变得庞大而无法管理；此时语法分析程序生成器这样的工具是更好的选择。它们无法构件抽象语法树即可解释表达式，这样可以节省空间而且还可能节省时间。 效率不是关键问题。最高效的解释器通常不是通过直接解释语法分析树实现的，而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下，转换器也可用解释器模式实现，该模
c++解析器模式
11-06 690
设计模式--解析器模式
解析器模式（C++）
weixin_47424753的博客
08-08 392
解析器模式；解析器模式（C++）；
C++软件设计模式之解释器模式
捕鲸叉的专栏
01-01 1383
解释器模式（Interpreter Pattern）是一种行为设计模式，主要用于定义一种语言的文法，并通过该文法解释语言中的句子（表达式）。解释器模式的核心思想是将一个特定的语言表示为其文法规则，并使用该文法规则来解释语言中的句子。
深入解析C++设计模式编程中解释器模式的运用
09-02
在C++中，解释器模式常用于创建一个程序，该程序能够理解并执行由特定语法规则定义的语言。它允许我们构建一个类层次结构，其中每个类代表语言的一个不同部分，从而实现对语言的解释。 在解释器模式中，有以下几个...
解析器模式（Interpreter Pattern）。
孤芳不自赏
09-21 599
定义 解释器模式是一种按照规定语法进行解析的方案，在现在项目中使用较少，其定义如下： 给定一门语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。 Expression——抽象解释器 具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和NonterminalExpression完成。 TerminalExpression...
【设计模式】行为型模式-解释器模式（Interpreter Pattern）
最新发布
weixin_43510208的博客
05-20 487
解释器模式（Interpreter Pattern） 是一种行为型设计模式，用于定义语言的语法规则，并提供解释器来处理这些规则。它将每个语法规则映射到一个类，通过组合这些类构建抽象语法树（AST），并递归解释执行节点。
设计模式之解析器模式实例（c++）
Sincky的博客
06-03 651
解析器模式 解析器模式定义语言的文法，并且建立一个解析器来解释该语言（规定格式和语法的代码）中的句子。它包含抽象表达式，终结符表达式，非终结符表达式，Context环境类。 解析器模式实例之数学运算解析器 Calculator类关联了一个抽象Node类，Node类比较复杂，需要通过Calculator中的build函数进行构建，Node类的构建是通过栈来进行联系的，通过栈可以维护比较复杂...
【设计模式】领域规则模式（解析器）
moX980的博客
05-13 297
领域规则模式 在特定的领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定领域，将问题抽象为语法规则，从而给出在该领域下的一般性解决方案 解析器interpretor 1.解析器interpretor 动机： 在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化 在这种情况下，将特定领域的问题表达为某种语法规则下的句子 然后构建一个解释器来解释这样的句子，从而达到解决问题的目的 比如a+b-c+d ： //语法树 #i
设计模式笔记—23_Interpreter解析器模式
Felix_hyfy的博客
03-04 399
文章目录Interpreter解析器模式是一种“领域规则”模式动机定义结构代码对比main.cpp说明要点总结 Interpreter解析器模式是一种“领域规则”模式 在特定领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定领域，将问题抽象为语法规则，从而给出在该领域下的一般性解决方案 动机 在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构在不断重复出现，如果使用普...
C++设计模式 - 解析器模式（Interpreter）
Cdreamfly的博客
03-25 1637
领域规则模式 在特定领域中,某些变化虽然频繁,但可以抽象为某种规则。这时候,结合特定领域,将问题抽象为语法规则,从而给出在该领域下的一般性解决方案。 典型模式 Interpreter Interpreter 动机( Motivation ) 在软件构建过程中,如果某一特定领域的问题比较复杂 ,类似的结构不断重复出现,如果使用普通的编程方式来实现将面临非常频繁的变化。 在这种情况下,将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子,从而达到解决问题的目的。 模式定义
设计模式之解析器（Interpreter）的C++实现
hanxiaoyong_的博客
09-17 519
设计模式之解析器（Interpreter）的C++实现。在软件开发的过程中，需要实现一种需求，该需求的结构稳定，但是需求的业务内容会频繁变化，如果使用普通语法实现需求，需要经常更新代码，不具有灵活性。可以使用解析器模式解决实现该类需求，解析器是实现一种能够解析该需求结构语法的功能代码，针对不同的业务调用对应的解析规则代码。有一个字符串的加减计算，如'a+b+c-d-e'，其中a,b,c,d,e分别对应带计算的值。
【Interpreter模式】C++设计模式——解析器
不负AC不负卿的博客
08-12 1214
C++解析器模式，Interpreter模式，本文以通俗易懂的举例帮助读者了解解析器，同时对解析器模式进行总结
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

OpenC++

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值