23.解析器模式.md

解析器模式 Interpreter

• 只有满足“业务规则频繁变化，且类似的结构不断重复出现，并且容易抽象为语法规则的问题”才适合使用
• 比较适合简单的文法表示

动机

在软件构建过程中，如果某一特定领域的问题比较复杂，类似的结构不断重复出现，如果使用普通的编程方式来实现将面临非常频繁的变化。

将特定领域的问题表达为某种语法规则下的句子，然后构建一个解释器来解释这样的句子，从而达到解决问题的目的。

模式定义

给定一个语言，定义它的文法的一种表示，并定义一种解释器，这个解释器使用该表示来解释语言中的句子。

代码

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

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

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

// 符号表达式
class SymbolExpression : public Expression{
protected:
    // 运算符左右两个参数
    Expression* left;
    Expression* right;
public:
    SymbolExpression(Expression* l, Expression* r) : left(l), right(r){}
};

// 加法运算
class AddExpression : public SymbolExpression{
public:
    AddExpression(Expression* l, Expression* r) : SymbolExpression(l, r){}

    int interpreter(map<char,int> var) override{
        return left->interpreter(var) + right->interpreter(var);
    }
};
// 减法运算
class SubExpression : public SymbolExpression{
public:
    SubExpression(Expression* l, Expression* r) : SymbolExpression(l, r){}

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

Expression* analyse(string expStr){
    stack<Expression*> expStack;
    Expression* left = nullptr;
    Expression* right = nullptr;
    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]));
        }
    }
    Expression* expression = expStack.top();
    return expression;
}

void release(Expression* expression){
    // 释放表达式树的节点内存
}

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

    Expression* expression = analyse(expStr);

    int result = expression->interpreter(var);
    cout << result << endl;

    release(expression);

    return 0;
}

题目

• 解释器模式-数学表达式