设计模式的 C++ 实现---解释器模式

最新推荐文章于 2024-08-15 07:08:53 发布
最新推荐文章于 2024-08-15 07:08:53 发布
阅读量255 收藏
点赞数
分类专栏： 设计模式 文章标签： 设计模式 c++ 字符串
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lizhichao410/article/details/108583876
版权

前文回顾
单例模式(一)
单例模式(二)
观察者模式
简单工厂模式
工厂方法模式(一)
工厂方法模式(二)
抽象工厂模式(一)
抽象工厂模式(二)
原型模式
外观模式
中介者模式
代理模式
装饰者模式
策略模式
状态模式
命令模式
建造者模式
桥接模式

前言

解释器模式的本质就是把一个依据确定规则组成的一个字符串翻译为计算机可执行的语句。

实现举例

  1. 场景描述
    输入一个四则运算的字符串，比如：a-10+b*(c+5) ，解析并返回计算结果。
  2. 表达式抽象基类
#include <string>
#include <iostream>
using namespace std;
class Context;
class Expression
{
public:
    virtual ~Expression(){}
    virtual double interpret(Context *ctx) = 0;
    virtual void display(Context *ctx) = 0;
};
  1. 变量表达式
#include "expression.h"

class Variable : public Expression
{
public:
    Variable(const string &m_name):virname(m_name){}
    virtual double interpret(Context *ctx) override;
    string getName() const { return  virname ;}
    void display(Context *ctx) override;

private:
    string virname;//变量名称
};

#include "variable.h"
#include "context.h"

double Variable::interpret(Context *ctx)
{
    return ctx->lookUpValue(this->virname);
}

void Variable::display(Context *ctx)
{
    cout << ctx->lookUpValue(this->virname);
}
  1. 解析字典类
#include "variable.h"
#include <map>
using namespace std;

class Context
{
public:
    void registerVariable(string var,double value)
    {
        m_map.insert(make_pair(var,value));
    }
    double lookUpValue(string var )
    {
        auto iter = m_map.find(var);
        if( iter != m_map.end() )
        {
            return  iter->second;
        }
        return  0;
    }
    bool findVariable(string var)
    {
        auto iter = m_map.find(var);
        if( iter != m_map.end() )
        {
            return  true;
        }
        return  false;
    }
private:
    map<string ,double> m_map;
};
  1. 常量表达式
#include "expression.h"

class Constant : public Expression
{
public:
    Constant(double value):m_value(value){}
    double interpret(Context *) override
    {
        return  m_value;
    }
    void display(Context *) override
    {
        cout << m_value;
    }
private:
    double m_value;
};
  1. 二元表达式
    ①．二元表达式基类
#include "expression.h"
#include "memory"
using namespace std;

class BinaryExpression : public Expression
{
public:
    BinaryExpression(shared_ptr<Expression> left,shared_ptr<Expression> right):leftExpression(left),rightExpression(right){}
protected:
    shared_ptr<Expression> leftExpression;
    shared_ptr<Expression> rightExpression;
};

②．加法表达式类

#include "binaryexpression.h"

class AddBinaryExpression : public BinaryExpression
{
public:
    using BinaryExpression::BinaryExpression;
    double interpret(Context *ctx) override
    {
        return leftExpression->interpret(ctx) + rightExpression->interpret(ctx);
    }
    void display(Context * ctx) override
    {
        leftExpression->display(ctx);
        cout << "+";
        rightExpression->display(ctx);
    }
};

③．减法表达式类

#include "binaryexpression.h"

class SubBinaryExpression : public BinaryExpression
{
public:
    using BinaryExpression::BinaryExpression;
    double interpret(Context *ctx) override
    {
        return leftExpression->interpret(ctx) - rightExpression->interpret(ctx);
    }
    void display(Context * ctx) override
    {
        leftExpression->display(ctx);
        cout << "-";
        rightExpression->display(ctx);
    }
};

④．乘法表达式类

#include "binaryexpression.h"


class MulBinaryExpression : public BinaryExpression
{
public:
    using BinaryExpression::BinaryExpression;
    double interpret(Context *ctx) override
    {
        return leftExpression->interpret(ctx) * rightExpression->interpret(ctx);
    }
    void display(Context * ctx) override
    {
        leftExpression->display(ctx);
        cout << "*";
        rightExpression->display(ctx);
    }
};

⑤．除法表达式类

#include "binaryexpression.h"

class DivBinaryExpression : public BinaryExpression
{
public:
    using BinaryExpression::BinaryExpression;
    double interpret(Context *ctx) override
    {
        return leftExpression->interpret(ctx) / rightExpression->interpret(ctx);
    }
    void display(Context * ctx) override
    {
        leftExpression->display(ctx);
        cout << "/";
        rightExpression->display(ctx);
    }
};
  1. 一元表达式
    ①．一元表达式基类
#include "expression.h"
#include <memory>
using namespace std;

class UnaryExpression : public Expression
{
public:
    UnaryExpression(shared_ptr<Expression> expression):mExpression(expression){}
protected:
    shared_ptr<Expression> mExpression;
};

②．正运算类

#include "unaryexpression.h"

class PositiveUnaryExpression : public UnaryExpression
{
public:
    using UnaryExpression::UnaryExpression;
    double interpret(Context *ctx) override
    {
        return  mExpression->interpret(ctx);
    }
    void display(Context * ctx) override
    {
        cout << "+";
        mExpression->display(ctx);
    }
};

③．负运算类

#include "unaryexpression.h"


class NegativeUnaryExpression : public UnaryExpression
{
public:
    using UnaryExpression::UnaryExpression;
    double interpret(Context *ctx) override
    {
        return - mExpression->interpret(ctx);
    }
    void display(Context * ctx) override
    {
        cout << "-";
        mExpression->display(ctx);
    }
};
  1. 解析类
#include "context.h"
#include <string>
#include <memory>
using namespace std;

class Expression;
class Calculator
{
public:
    Calculator(const string &expression,shared_ptr<Context> &contex):m_expression(expression),m_contex(contex){}
    bool  getCalculatorResult(double &result,string &error);


private:
    string m_expression;//要解析的表达式
    int curIndex =0;//当前解析到的位置
    shared_ptr<Context> m_contex;//解析字典

    bool ReadConstant(shared_ptr<Expression> &exp);//读取一个常量数字
    bool ReadVariable(shared_ptr<Expression> &exp);//读取一个变量
    bool ReadOperator(const char & oper);//读取一个操作符
    bool ReadExpression(shared_ptr<Expression> &exp,string &error);//读取一个表达式
    bool ReadFactor(shared_ptr<Expression> &exp,string &error);//读取一个优先计算的独立表达式
    bool ReadIterm(shared_ptr<Expression> &exp,string &error);//读取一个独立项


};

#include "calculator.h"
#include "expression.h"
#include "addbinaryexpression.h"
#include "subbinaryexpression.h"
#include "mulbinaryexpression.h"
#include "divbinaryexpression.h"
#include "positiveunaryexpression.h"
#include "negativeunaryexpression.h"
#include "constant.h"
#include "variable.h"


bool Calculator:: getCalculatorResult(double &result,string &error)
{
    //删除开头空格
    m_expression.erase(0,m_expression.find_first_not_of(" "));

    shared_ptr<Expression> exp;
    if( ReadExpression(exp,error))
    {
       cout << "表达式解析为:";
       exp->display(m_contex.get()) ;
       cout << endl;
       result = exp->interpret(m_contex.get());
       return  true;
    }
    return false;
}

bool Calculator::ReadConstant(shared_ptr<Expression> &exp)
{
    bool readNum = false;
    bool readPoint = false;
    string resDouble = "";
    for( ;curIndex< (int)m_expression.size();++curIndex)
    {
        if( m_expression[curIndex] >= '0' && m_expression[curIndex] <= '9')
        {
            readNum = true;
            resDouble.push_back(m_expression[curIndex]);
        }
        else if( m_expression[curIndex] == '.')
        {
            if(readNum && !readPoint)
            {
                readPoint = true;
                resDouble.push_back(m_expression[curIndex]);
            }
            else
                break;
        }
        else
        {
            break;
        }
    }
    if( resDouble != "")
    {
        exp = make_shared<Constant>(atof(resDouble.c_str()));
        return true;
    }
    return false;
}

bool Calculator::ReadExpression(shared_ptr<Expression> &resultFactor,string &error)
{
    shared_ptr<Expression> nextFactor;
    bool isok = true;
    if( ReadFactor(resultFactor,error))//读取到了一个优先计算的独立表达式
    {
        while(true)//循环读取
        {
            if(curIndex < (int)m_expression.size() )
            {
                if( ReadOperator('+'))
                {
                    if( ReadFactor(nextFactor,error))
                        resultFactor = make_shared<AddBinaryExpression>(resultFactor,nextFactor);
                    else//读取下一项失败
                    {
                        isok = false;
                        break;
                    }
                }
                else  if( ReadOperator('-'))
                {
                    if( ReadFactor(nextFactor,error))
                        resultFactor = make_shared<SubBinaryExpression>(resultFactor,nextFactor);
                    else//读取下一项失败
                    {
                        isok = false;
                        break;
                    }
                }
                else break;
            }
            else break;
        }
    }
    else//读取失败
    {
        isok = false;
    }
    return isok;

}

bool Calculator::ReadFactor(shared_ptr<Expression> &resultIterm,string &error)
{
    shared_ptr<Expression> nextIterm;
    bool isok = true;
    if( ReadIterm(resultIterm,error))
    {
        while(true)
        {
            if(curIndex < (int)m_expression.size() )
            {
                if(ReadOperator('*'))
                {
                    if(ReadIterm(nextIterm,error))
                        resultIterm = make_shared<MulBinaryExpression>(resultIterm,nextIterm);
                    else
                    {
                        isok = false;
                        break;
                    }
                }
                else if(ReadOperator('/'))
                {
                    if(ReadIterm(nextIterm,error))
                        resultIterm = make_shared<DivBinaryExpression>(resultIterm,nextIterm);
                    else
                    {
                        isok = false;
                        break;
                    }
                }
                else  break;
            }
            else break;
        }
    }
    else
    {
        isok = false;
    }
    return  isok;
}

bool Calculator::ReadIterm(shared_ptr<Expression> &exp,string &error)
{
    bool isok = true;
    if(ReadConstant(exp)) {} //读取到一个常量数字
    else if ( ReadVariable(exp)) { }
    else if( ReadOperator('('))//读到左括号
    {
        if(  ReadExpression(exp,error) )
        {
            if(!ReadOperator(')'))
            {
                error = "解析失败:在位置:"+to_string(curIndex)+" 没有解析到右括号";
                isok = false;
            }
        }
        else
            isok = false;
    }
    else if( ReadOperator('+'))
    {
        shared_ptr<Expression> nextFactor;
        if( ReadFactor(nextFactor,error))
        {
            exp = make_shared<PositiveUnaryExpression>(nextFactor);
        }
        else
            isok = false;
    }
    else if(ReadOperator('-'))
    {
        shared_ptr<Expression> nextFactor;
        if( ReadFactor(nextFactor,error))
        {
            exp = make_shared<NegativeUnaryExpression>(nextFactor);
        }
        else
            isok = false;
    }
    else
    {
        isok = false;
        error = "解析失败:位置:"+to_string(curIndex)+" 无法解析";
    }
    return isok;
}

bool Calculator::ReadVariable(shared_ptr<Expression> &exp)
{
    string temp;
    temp.push_back(m_expression[curIndex]);
    shared_ptr<Variable> var(new Variable(temp));
    if(m_contex->findVariable(temp))
    {
        exp = var;
        curIndex++;
        return true;
    }
    return  false;
}

bool Calculator::ReadOperator(const char &oper)
{
    if( m_expression[curIndex] == oper)
    {
        curIndex++;
    }
    else
    {
        return  false;
    }
    return true;
}
  1. 客户端调用
    在这里插入图片描述
#include "calculator.h"

#include <iostream>
using namespace std;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    string expression = "a-10+b*(c+5)";

    shared_ptr<Context> context(new Context() );

    context->registerVariable("a",10);
    context->registerVariable("b",200);
    context->registerVariable("c",5);
    context->registerVariable("d",20);

    Calculator * calculator = new  Calculator(expression,context);
    string error;
    double result;
    calculator->getCalculatorResult(result,error);
    cout << "计算结果为:"<<result;


    return a.exec();
}

在这里插入图片描述

litanyuan
关注
专栏目录
C++ 解释器模式
xiaobeibei2的博客
08-07 342
解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护。 建议当文法非常复杂时，使用其他的技术如语法分析程序或编译器来处理。
c++设计模式-行为型模式-解释器模式
06-26
c++设计模式-行为型模式-解释器模式；qt工程；c++简单源码； 解释器（Interpreter）模式的定义：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式...
3_11 InterpreterMode 解释器模式
liujiayu2的专栏
04-16 749
这篇文章主要介绍了C++设计模式之解释器模式,本文讲解了什么是解释器模式、文法规则和抽象语法树、解释器模式的使用场合等内容,需要的朋友可以参考下 前言 那日，闲的无聊，上了一个在线编程学习网站；最近那个在线编程学习网站很火啊；之前，盖茨、扎克伯格等大人物都来宣传了，思想是人人都应该学习编程；我一想就这算怎么回事啊？这要是在中国，还让人活不？话题不扯开了，还是说我上了那个在线编程网站
在 C++ 中实现自定义的配置文件解析器
最新发布
windowshht的博客
08-15 834
配置文件是一种用于存储应用程序设置的文件，通常采用文本格式。配置文件可以包含键值对、数组、注释等信息，便于用户进行修改和管理。常见的配置文件格式包括 INI、JSON、XML 和 YAML 等。首先，我们定义一个结构体来表示配置项。public:private:在这个示例中，ConfigItem类包含一个键和一个值，值的类型使用来支持多种数据类型（如整数、浮点数和字符串）。本文介绍了如何在 C++ 中实现一个自定义的配置文件解析器。
设计模式之解释器模式（C++）
konglongdanfo的博客
10-27 1459
设计模式之解释器模式 解释器模式，给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。解释器模式解决的问题是，如果一种特定类型的问题发生的频率足够高，那么可能就只得将该问题的各个示例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决问题。 其UML图如下： 在解释器模式中每一种表达式对应一种表达式解释类，比如Termi...
C++设计模式——解释器模式（Interpreter）
qq_33766994的博客
03-31 659
解释器模式 在软件构建中，若某一特定领域的问题比较复杂，类似的结果不断重复出现，使用普通的编程方式来实现的话面临非常频繁的重复操作。 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。 #include <iostream> #include <map> #include <stack> using namespace std; class Expression { public: virtual int
我所理解的设计模式（C++实现）——解释器模式（Interpreter Pattern）
runfeel
07-06 231
概述： 未来机器智能化已然成为趋势，现在手机都能听懂英语和普通话，那我大中华几万种方言的被智能化也许也是趋势，我们的方言虽然和普通话相似，但是还是不一样的。这可能需要一个新的语法分析器来帮助我们。 我们的解释器模式就是描述了如何为简单的语言定义一个文法，如何在该语言中表示一个句子，以及如何解释这些句子。 但是解释一门自然语言是复杂的过程，我们以加减运算为例子来详细解释解释器模式。 ...
设计模式精解-GoF-23种设计模式解析--附C++源代码
02-18
- 解释器模式（Interpreter）：给定一种语言，定义它的文法表示，并提供一个解释器来处理这种语言中的句子。 - 迭代器模式（Iterator）：提供一种方法顺序访问聚合对象的元素，而又不暴露其底层表示。 - 中介者...
23种设计模式-C++实现.zip
05-16
这个名为"23种设计模式-C++实现.zip"的压缩包文件包含了C++语言实现的全部23个经典设计模式。下面我们将详细探讨这些设计模式及其在C++中的应用。 1. **创建型设计模式**： - **单例模式（Singleton）**：确保一个...
《Head First设计模式》学习代码，使用C++实现-Book-HFDP-Code.zip
01-31
23. **解释器模式 (Interpreter)**：给定一个语言，定义它的文法表示，并且给出一个解释器，该解释器用于给定表示的实例解释句子。在C++中，可能会有一个Expression基类和多个表示特定运算的子类，解释器使用这些类...
23种设计模式的C++实现DesignPattern-master.zip
03-18
- **解释器模式（Interpreter）**：给定一种语言，定义它的文法表示，并提供一个解释器来解释语言中的句子。 - **状态模式（State）**：允许对象在其内部状态改变时改变它的行为，对象看起来似乎修改了它的类。 -...
设计模式之解释器模式（Interpreter）
07-07
解释器模式(Interpreter) 用意：定义一种语言，定义它的方法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。
c++解释器模式
waxtear的博客
02-21 542
本文主要运用解释器来解析数学表达式。其中还用到了生产者模式，代理模式，策略模式，状态模式，模板方法，单例模式。
设计模式之解释器模式(C++实现)
墨1024
01-05 826
解释器模式介绍，包括应用场景，优缺点，模式结构，类图 以及 C++代码示例
设计模式---解释器模式(C++实现)
CodingStart
03-17 819
解释器模式(Interpreter Pattern)提供了评估语言的 或者表达式的方式，属于行为型模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在SQL解析、符号处理引擎等。 意图          给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。 解决问题          对于一些固定文法构建一个结
解释器模式（C++实现）
qq_23903863的博客
08-05 527
（本博客旨在个人总结回顾） 1、详情： 解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 说明： 优点： ①可扩展性比较好，灵活。 ②增加了新的解释表达式的方式。 ③易于实现简单文法。 缺点： ①可利用场景比较少。 ②对于复杂的文法比较难维护。 ③解释器模式会引起类膨胀。 ④解释器模式采用递归调用方法。 使用场...
设计模式之解释器模式(C++)
热门推荐
翟天保的博客
04-26 1万+
介绍设计模式之解释器模式
设计模式：解释器模式（Interpreter）
weixin_34006965的博客
04-04 175
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 解释器模式的角色： 1. 抽象表达式角色（AbstractExpression）：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要是一个interpret()方法，称作解释操作。 2. 终结符表达式角色（Termina...
设计模式——解释器模式（C++实现）
Skynet的博客
06-26 593
解释器模式简介 解释器模式（Interpreter Pattern）提供了评估语言的语法或表达式的方式，属于行为型模式。 这种模式实现了一个表达式接口，该接口解释一个特定的上下文。常被用在 SQL 解析、符号处理引擎等。 适用场景 1、当有一个语言需要解释执行 , 并且你可将该语言中的句子表示为一个抽象语法树时，可使用解...
C++设计模式解析：深入理解解释器模式
"C++设计模式之解释器模式" 解释器模式是一种行为设计模式，它允许我们定义一种语言的文法，并创建一个解释器来处理这种语言中的句子。在C++中，解释器模式通常用于处理简单的语言或表达式，例如控制指令、配置脚本...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值