设计模式-解析器-笔记

“领域规则”模式

在特定领域中，某些变化虽然频繁，但可以抽象为某种规则。这时候，结合特定领域，将稳日抽象为语法规则，从而给出在该领域下的一般性解决方案。

典型模式：Interpreter

动机(Motivation)

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

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

模式定义：

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

示例:

#include <iostream>
#include <map>
#include <stack>

using namespace std;

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

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

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

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

public:
    SymbolExpression(Expression* left, Expression* right) {
        this->left = left;
        this->right = 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;
    Expression* right;

    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;
        }
    }

    return expStack.top();
}

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

int main() {
    string 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;
}