/*小魚號(hào)的代碼日志
 * 設(shè)計(jì)模式
 * 解釋器模式
 * 當(dāng)一個(gè)語言需要解釋執(zhí)行，可將該語句中的句子表示為一個(gè)抽象語法樹，
 * 就可以考慮使用解釋器模式，讓程序具有良好的擴(kuò)展性
 * 帶來的問題:
 * 解釋器模式會(huì)引起類膨脹，解釋器模式采用遞歸調(diào)用的方法，將會(huì)導(dǎo)致
 * 調(diào)用非常復(fù)雜，效率可能降低
 * 實(shí)例：
 *  計(jì)算加減乘除
 */

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

///抽象類表達(dá)式 通過map可以獲取變量的值
class Expression
{
public:
    virtual int interpreter(map<char,int> var) = 0;
};

///變量的解釋器
class VarExpression :public Expression
{
public:
    VarExpression(char key)
    {
        m_key = key;
    }
    virtual int interpreter(map<char,int> var)
    {
        return var[m_key];
    }
private:
    char m_key;
};

///抽象運(yùn)算符號(hào)解析器 每個(gè)運(yùn)算符號(hào)都只和自己左右連個(gè)數(shù)字有關(guān)系
///但左右兩個(gè)數(shù)字有可能也是一個(gè)解析的結(jié)果，無論何種類型都是expression類的實(shí)現(xiàn)類
class SymbolExpression:public Expression
{
public:
    SymbolExpression(Expression* leftExpression,Expression* rightExpression)
    {
        m_leftExpression = leftExpression;
        m_rightExpression = rightExpression;
    }
    ///因?yàn)閟ybmol 是讓子類來實(shí)現(xiàn) 因此interpreter是一個(gè)默認(rèn)的實(shí)現(xiàn)
    int interpreter(map<char, int> var)
    {
        return 0;
    }
protected:
    Expression* m_leftExpression;
    Expression* m_rightExpression;
};

class AddExpression :public SymbolExpression
{
public:
    AddExpression(Expression* leftExpression ,Expression* rightExpression):
     SymbolExpression(leftExpression,rightExpression)
    {

    }
    virtual int interpreter(map<char,int> var)
    {
       return m_leftExpression->interpreter(var) + m_rightExpression->interpreter(var);
    }
};

class SubExpression :public SymbolExpression
{
public:
    SubExpression(Expression* leftExpression ,Expression* rightExpression):
     SymbolExpression(leftExpression,rightExpression)
    {

    }
    virtual int interpreter(map<char,int> var)
    {
       return m_leftExpression->interpreter(var) - m_rightExpression->interpreter(var);
    }
};

class Calculator
{
public:
    Calculator(string expStr)
    {
        stack<Expression*> stack;
        Expression* left = nullptr;
        Expression* right = nullptr;
        for(int i = 0; i < expStr.size(); i++)
        {
            switch (expStr[i])
            {
                case '+':
                    left = stack.top();
                    stack.pop();
                    right = new VarExpression(expStr[++i]);
                    stack.push(new AddExpression(left,right));
                    break;
                case '-':
                    left = stack.top();
                    stack.pop();
                    right = new VarExpression(expStr[++i]);
                    stack.push(new SubExpression(left,right));
                    break;
                default:
                    stack.push(new VarExpression(expStr[i]));
            }
        }
        m_expression = stack.top();
    }
    int run(map<char,int> var)
    {
        return m_expression->interpreter(var);
    }
private:
    Expression* m_expression;
};

///解釋器模式
void testInterpreter()
{
    cout << "interpreter patterns" << endl;
    ///利用解釋器模式計(jì)算表達(dá)式a+b-c
    Calculator calc("a-b+c");
    map<char,int> var;
    var.insert(make_pair('a',10));
    var.insert(make_pair('b',5));
    var.insert(make_pair('c',7));
    cout << calc.run(var) << endl;

    map<char,int> var2;
    var2.insert(make_pair('a',8));
    var2.insert(make_pair('b',1));
    var2.insert(make_pair('c',50));
    cout << calc.run(var2) << endl;
}