设计模式-解析器模式

解释器（Interpreter）模式的定义：给分析对象定义一个语言，并定义该语言的文法表示，再设计一个解析器来解释语言中的句子。也就是说，用编译语言的方式来分析应用中的实例。这种模式实现了文法表达式处理的接口，该接口解释一个特定的上下文。

#include <QCoreApplication>
#include <iostream>
#include <map>
#include <stack>
#include <string>
using namespace std;

class Expression{
public:
    virtual int interpreter(map<char,int>var)=0;
};

//变量表达式
class VarExpression:public Expression{
public:
    VarExpression(const char& key){
        this->key = key;
    }

    int interpreter(map<char,int>var){
        return var[key];
    }
private:
    char key;
};


//符号表达式
class SymbolExpression:public Expression{
public:
    SymbolExpression(Expression* left,Expression* right){
        this->left = left;
        this->right = right;
    }
protected:
    Expression* left;
    Expression* right;
};

//加法运算
class AddExpression:public SymbolExpression{
public:
    AddExpression(Expression* left,Expression* right):SymbolExpression(left,right){

    }

    int interpreter(map<char,int>var){
        return  left->interpreter(var) + right->interpreter(var);
    }
};


//减法运算
class SubExpression:public SymbolExpression{
public:
    SubExpression(Expression* left,Expression* right):SymbolExpression(left,right){

    }

    int interpreter(map<char,int>var){
        return  left->interpreter(var) - right->interpreter(var);
    }
};

Expression* analyse(string expStr){
    stack<Expression*>expStack;
    Expression* left = NULL;
    Expression* right = NULL;
    for(int i = 0; i < expStr.size();i++){
        switch (expStr[i]) {
        case '+':
            left = expStack.top();
            right = new VarExpression(expStr[++i]);
            expStack.push(new AddExpression(left,right));
            break;
        case '-':
            left = expStack.top();
            right = new VarExpression(expStr[++i]);
            expStack.push(new SubExpression(left,right));
            break;
        default:
            //变量表达式
            expStack.push(new VarExpression(expStr[i]));
            break;
        }
    }
    Expression* expression = expStack.top();
    return expression;
}


int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    string expStr="a-b+c+d";
    map<char,int>var;
    var.insert(make_pair('a',5));
    var.insert(make_pair('b',3));
    var.insert(make_pair('c',2));
    var.insert(make_pair('d',7));

    Expression* expression = analyse(expStr);
    int result = expression->interpreter(var);
    cout<<result<<endl;

    return a.exec();
}