解释器模式(Interpreter Pattern)：给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。 （用在SQL解析、符号处理引擎等）
解释器模式：
对输入的内容，构建语法树，按照特定的规则进行解析。
概要分析：
就是对输入的字符进行语法，词法分析，比如数学运算的计算等
使用场景：
比如：处理器，硬盘控制器，浏览器等对输入的信息做不同的解析。
比如：使用指令，控制一套机器人系统
样例Demo：
参考来源：设计模式C++实现（20）——解释器模式_crkres9527-CSDN博客_c++ 解释器模式
感觉这个时解释器的精髓：把复杂的输入解析出想要的结果。 直接拿来用，没有细节分析
//行为型模式：解释器模式 //场景：四则运算 #include <iostream> #include <string> #include <map> #include <stack> #include <typeinfo> using namespace std; //*******************************************抽象表达式类*********************************** class Expression { public: //解析公式和数值，其中var中的key是公式中的参数，value值是具体的数字 //如a = 100; b = 20; c = 40 virtual int interpreter(map<string, int>& var) = 0; virtual ~Expression(){}; }; //变量解析器（终结符表达式） class VarExpression : public Expression { string key; public: VarExpression(string key) { this->key = key; } //从map中取出变量的值 int interpreter(map<string, int>& var) { return var[key]; } ~VarExpression() { cout << "~VarExpression()" << endl; } }; //**********抽象运算符号解析器*********************** //抽象运算符号解析器 class SymbolExpression : public Expression { protected: Expression* left; Expression* right; public: SymbolExpression(Expression* left, Expression* right) { this -> left = left; this -> right = right; } Expression* getLeft() { return left; } Expression* getRight() { return right; } }; //加法解析器 class AddExpression : public SymbolExpression { public: AddExpression(Expression* left, Expression* right): SymbolExpression(left,right) { } //把左右两个表达式运算的结果加起来 int interpreter(map<string, int>& var) { return left->interpreter(var) + right ->interpreter(var); } ~AddExpression() { cout << "~AddExpression()" << endl; } }; //减法解析器 class SubExpression : public SymbolExpression { public: SubExpression(Expression* left, Expression* right): SymbolExpression(left,right) { } //把左右两个表达式运算的结果相减 int interpreter(map<string, int>& var) { return left->interpreter(var) - right ->interpreter(var); } ~SubExpression() { cout << "~SubExpression()" << endl; } }; //*********************************解析器封装类*************************************** //解析器封装类，这个类是根据迪米特法则进行封装，目的是让Client只与直接朋友打交道，相当于Facade class Calculator { private: Expression* expression; public: //构造函数传参，并解析表达式，构建语法树 Calculator(string expStr) { expression = NULL; //栈，用来暂存中间结果 stack<Expression*> stkExp; Expression* left = NULL; Expression* right = NULL; /*从左到向分析表达式（如:a+b-c)，最终的语法树如下： * - * / \ * + c * / \ * a b */ for(unsigned int i = 0; i< expStr.length(); i++) { switch(expStr[i]) { case '+': //加法 //1.先从栈中取出左操作数 left = stkExp.top(); stkExp.pop(); //2.从表达式中取出+号后面的右操作数，并生成终结符解析对象 right = new VarExpression(expStr.substr(++i,1)); //3.将左右操作数相加，并把结果放入栈中 stkExp.push(new AddExpression(left, right)); break; case '-': //1.先从栈中取出左操作数 left = stkExp.top(); stkExp.pop(); //2.从表达式中取出+号后面的右操作数，并生成终结符解析对象 right = new VarExpression(expStr.substr(++i,1)); //3.将左右操作数相减，并把结果放入栈中 stkExp.push(new SubExpression(left, right)); break; default: //如果是变量（终结符）：如a+b+c中的a\b\c， //则直接生成对应的变量解析器对象 stkExp.push(new VarExpression(expStr.substr(i,1))); } } //栈中保存的就是最终语法树的根结点（本例为SuuExpression对象） if(!stkExp.empty()) { expression = stkExp.top(); stkExp.pop(); } } void deltree(Expression* expression) { SymbolExpression* branch = dynamic_cast<SymbolExpression*>(expression); //叶子结点 if (branch == NULL) { delete expression; } else //分支结点 { //左子树 deltree(branch->getLeft()); //右子树 deltree(branch->getRight()); //结点 delete expression; } } ~Calculator() { deltree(expression); expression = NULL; } //开始运算 int run(map<string, int>& var) { return (expression == NULL) ? 0 : expression->interpreter(var); } }; int main() { string expStr = "a+b-c"; //为简化处理，这里必须是合法的表达式 map<string, int> var; //相当于Interpreter模式中的Context var["a"] = 100; var["b"] = 20; var["c"] = 40; Calculator cal(expStr); cout <<"运算结果为：" << expStr << " = " << cal.run(var) << endl; return 0; } /* 运算结果为：a+b-c = 80 ~VarExpression() ~VarExpression() ~AddExpression() ~VarExpression() ~SubExpression() */
demo2：也是参考，只是简单梳理：
//解释器模式 #include <iostream> #include <string> using namespace std; //只是提供一个解释器的中间类，为解释语句做辅助功能，输入要时特定的格式 class Context { public: //通过此类进行中间变量的存储和运算，得到数据通过此类，修改也是通过此类 Context(int num){ m_num = num;} public: void setNum(int num){ m_num = num;} int getNum(){ return m_num;} void setRes(int res){ m_res = res;} int getRes(){ return m_res;} private: int m_num; int m_res; }; //解释器基类 调用接口的入口而已，子类真正调用入参，根据不同的解释做处理 //可以定义一个基类 实现多个子类不同的解释功能，如运算符+，-，*，/ class Expression { public: virtual void interpreter(Context *context) = 0; }; //可以对输入做不同的解析 这里只做了输出 class PlusExpression : public Expression { public: virtual void interpreter(Context *context) { int num = context->getNum(); num++; context->setNum(num); context->setRes(num); } }; //可以对输入做不同的解析 这里只做了输出 class MinusExpression : public Expression { public: virtual void interpreter(Context *context) { int num = context->getNum(); num--; context->setNum(num); context->setRes(num); } }; int main() { //通过一个中间类进行数据的存储转化和设置 Context *explain = new Context(10);//设置要解释的内容 Expression *e1 = new PlusExpression;//设置解释器 e1->interpreter(explain);//调用解释器内的解释函数 cout << "PlusExpression:" << explain->getRes() << endl;//得到数据结果 Expression *e2 = new MinusExpression; e2->interpreter(explain); cout << "MinusExpression:" << explain->getRes() << endl; delete explain; delete e2; delete e1; // system("pause"); return 0; }
