递归下降求解表达式

#include <iostream>
#include <string>
using namespace std;

enum Error_Type{
    NONE_ERROR,
    ERR_DIV_ZERO,
    ERR_DISMATCH_RBRACKET,
    ERR_MULTIPLE_DOT
};
static string SError_Type[]{
    "NONE_ERROR",
    "ERR_DIV_ZERO",
    "ERR_DISMATCH_RBRACKET",
    "ERR_MULTIPLE_DOT"
};

class Calculator
{
public:
    Calculator()
    {
        expression = "";
        pos = 0;
        error = NONE_ERROR;
    }
    double operator()(const string &exp)
    {
        expression = removeBlank(exp);
        pos = 0;
        error = NONE_ERROR;
        double value=evalExpression();
        if(error){
            cout<<SError_Type[error]<<endl;
        }
        return value;
    }

private:


    string expression;
    int pos;
    Error_Type error;

    string removeBlank(const string &exp)
    {
        string text;
        for (auto c : exp)
        {
            if(isdigit(c)||c=='.'||c=='+'||c=='-'||c=='*'||c=='/'||c=='('||c==')'){//过滤输入,只允许特定的运算符,数字,小数点进入expression
                text+=c;
            }
        }
        return text;
    }
    bool end()
    {
        return expression[pos] == '\0';
    }
    double evalExpression()
    {
        double term;
        double result = 0;
        char op;
        term = evalTerm();
        if (error)
        {
            return 0;
        }

        result = term;
        while (!end())
        {
            op = expression[pos];
            if (op != '+' && op != '-')
            {
                break;
            }
            ++pos;
            term = evalTerm();
            if (error)
            {
                return 0;
            }
            switch (op)
            {
            case '+':
                result += term;
                break;
            case '-':
                result -= term;
                break;
            }
        }
        return result;
    }
    double evalTerm()
    {
        double factor;
        double result = 1;
        char op;
        factor = evalFactor();
        if (error)
        {
            return 0;
        }
        result = factor;
        while (!end())
        {
            op = expression[pos];
            if (op != '*' && op != '/')
            {
                break;
            }
            ++pos;
            factor = evalFactor();
            switch (op)
            {
            case '*':
                result *= factor;
                break;
            case '/':
                if (factor == 0)//避免检查错误
                {
                    error = ERR_DIV_ZERO;
                    return 0;
                }
                result /= factor;
            }
        }
        return result;
    }
    double evalFactor()
    {
        double result;
        if (expression[pos] == '(')
        {
            ++pos;
            result = evalExpression();
            if(error){
                return 0;
            }
            if (expression[pos]!=')')
            {
                error=ERR_DISMATCH_RBRACKET;
                return 0;
            }

            ++pos;
        }

        else if (expression[pos] == '-')
        {
            ++pos;
            result=evalFactor();
            if(error){
                return 0;
            }
            else  result*=-1;
        }
        else if (isdigit(expression[pos]))
        {
            result=evalID();
            if(error){
                return 0;
            }
        }
        return result;
    }


    double evalID()
    {
        bool dot_flag=false;//一个分数中最多只能有一个小数点
        string buffer;
        while (!end())
        {
            if(expression[pos]!='.'&&!isdigit(expression[pos])){
                break;
            }
            else if(expression[pos]=='.'){
                if(dot_flag==false){
                    dot_flag=true;
                }
                else{
                    error=ERR_MULTIPLE_DOT;
                    return 0;
                }
                buffer+=expression[pos];
            }

            buffer+=expression[pos];
            ++pos;
        }

        return stof(buffer);
    }
}calc;

int main()
{
    string expression;
    while(cin>>expression){
        cout<<calc(expression)<<endl;
    }
    return 0;
}