解释器模式

#ifndef INTERPRETER_H
#define INTERPRETER_H

#include <QDebug>
#include <iostream>
#include <QString>
#include <QMap>
#include <QStack>
#include <typeinfo>

class Expression
{
public:
    Expression() {};
    virtual ~Expression() {};

    /**
    * @brief : 解析公式和数值
    * @param[in] : var key是公式中的参数，value值是具体的数字
    * @return : int
    */
    virtual int interpreter(QMap<QString, int>& var) = 0;
};


class VarExpression : public Expression
{
public:
    VarExpression(QString key)
        : m_key(key)
    {};
    ~VarExpression() {};

    int interpreter(QMap<QString, int>& var)
    {
        return var[m_key];
    }

private:
    QString            m_key;
};

class SymbolExpression : public Expression
{
public:
    SymbolExpression(Expression* left, Expression* right)
        : m_left(left)
        , m_right(right)
    {};

    Expression* getLeft()
    {
        return m_left;
    }
    Expression* getRight()
    {
        return m_right;
    }
protected:
    Expression*            m_left;
    Expression*            m_right;
};

//加法解析器
class AddExpression : public SymbolExpression
{
public:
    AddExpression(Expression* left, Expression* right)
        : SymbolExpression(left, right)
    {};
    ~AddExpression() {};

    int interpreter(QMap<QString, int>& var)
    {
        return m_left->interpreter(var) + m_right->interpreter(var);
    }
};

//减法解析器
class SubExpression : public SymbolExpression
{
public:
    SubExpression(Expression* left, Expression* right)
        : SymbolExpression(left, right)
    {};
    ~SubExpression() {};

    int interpreter(QMap<QString, int>& var)
    {
        return m_left->interpreter(var) - m_right->interpreter(var);
    }
};

class Calculator
{
public:
    Calculator(QString expStr)
        : m_expression(nullptr)
    {
        init(expStr);
    };

    ~Calculator()
    {
        deletetree(m_expression);
        m_expression = nullptr;
    }

    void deletetree(Expression* expression)
    {
        SymbolExpression* branch = dynamic_cast<SymbolExpression*>(expression);
        if (nullptr == branch)
        {
            delete expression;
        }
        else
        {
            deletetree(branch->getLeft());
            deletetree(branch->getRight());

            delete expression;
        }
    }


    int run(QMap<QString, int>& var)
    {
        if (nullptr == m_expression)
        {
            return 0;
        }

        return m_expression->interpreter(var);
    }
private:
    void init(QString expStr)
    {
        QStack<Expression*> stkExp;

        Expression* left = nullptr;
        Expression* right = nullptr;

        for (quint32 i = 0; i < expStr.length(); i++)
        {
            if (‘+‘ == expStr.at(i))
            {
                left = stkExp.top();
                stkExp.pop();
                right = new VarExpression(expStr.mid(++i, 1));

                stkExp.push(new AddExpression(left, right));
            }
            else if (‘-‘ == expStr.at(i))
            {
                left = stkExp.top();
                stkExp.pop();
                right = new VarExpression(expStr.mid(++i, 1));

                stkExp.push(new SubExpression(left, right));
            }
            else
            {
                stkExp.push(new VarExpression(expStr.mid(i, 1)));
            }
        }
        if (!stkExp.empty())
        {
            m_expression = stkExp.top();
            stkExp.pop();
        }
    }
private:
    Expression* m_expression;
};

#if 1

#define FREE_OBJ(obj)        if (nullptr != (obj)){delete (obj); (obj) = nullptr;}

int main()
{
    QString expStr = "a+b-c";

    QMap<QString, int> contextMap;
    var["a"] = 80;
    var["b"] = 66;
    var["c"] = 100;

    Calculator *cal = new Calculator(expStr);
    qDebug() << "result：" << expStr << " = " << cal.run(contextMap);

    FREE_OBJ(cal);

    return 0;
}

#endif // 1

#endif // !Interpreter.h