简易四则运算计算器

#include <string>
#include <stack>
#include <vector>

using std::string;
using std::vector;
using std::stack;

class Element {
public:
    static Element MakeData(double value_) {return Element(DATA, value_, ' ');}
    static Element MakeOp(char op) {return Element(OP, 0.0, op);}
    bool isData() const { return t == DATA; }
    bool isOp() const { return t == OP; }
    char getOp() const { return op;}
    double getValue() const { return value; }
    int priority() const {
        if (isOp()) {
            if (getOp() == '*' || getOp() == '/') {
                return 2;
            } else if (getOp() == '+' || getOp() == '-') {
                return 1;
            } else if (getOp() == '(' || getOp() == ')') {
                return 0;
            }
        }
        return -1;
    }
private:
    enum Type {DATA, OP};
    Type t;
    double value;
    char op;
    Element(Type t_, double value_, char op_) : t(t_), value(value_), op(op_) {}
 };

bool isOp(char c) {
    return c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')';
}

// 判断当前的 + - 是否为单目操作符 比如 （-3）
bool isSign(const string &input, size_t i) {
    char c = input[i];
    if (c == '+' || c == '-') {
        if (i == 0) {
            return true;
        }
        if (input[i - 1] == '(') {
            return true;
        }
    }
    return false;
}

vector<Element> str2mid(const string &input) {
    vector<Element> mid;
    string data;
    for (size_t i = 0; i < input.length(); i++) {
        if (isSign(input, i)) {
            data += input[i];
            continue;
        }
        if (isOp(input[i])) {
            if (data != "") {
                mid.push_back(Element::MakeData(std::stod(data)));
                data = "";
            }
            mid.push_back(Element::MakeOp(input[i]));
        } else if (!isspace(input[i])){
            data += input[i];
        }
    }
    if (data != "") {
        mid.push_back(Element::MakeData(std::stod(data)));
        data = "";
    }
    return mid;
}

vector<Element> mid2post(const vector<Element> &mid) {
    stack<Element> s;
    vector<Element> post;
    for (auto it = mid.begin(); it != mid.end(); it++) {
        if (it->isData()) { // 如果是操作数，直接输出
            post.push_back(*it);
        } else if (it->isOp() && it->getOp() == '(') { // 如果是'('直接入栈
            s.push(*it);
        } else if (it->isOp() && it->getOp() == ')') { // 如果是')'将栈中'('之后的操作符出栈
            while(!s.empty() && s.top().getOp() != '(') {
                post.push_back(s.top());
                s.pop();
            }
            s.pop();
        } else if (it->isOp()) { // 如果是操作符 出栈直到栈顶优先级低于该操作符，其中'('的优先级最低，然后把该操作符入栈
            while(!s.empty() && s.top().priority() >= it->priority()) {
                post.push_back(s.top());
                s.pop();
            }
            s.push(*it);
        }
    }
    while(!s.empty()) { // 栈中元素全部出栈
        post.push_back(s.top());
        s.pop();
    }
    return post;
}

double calc_post(const vector<Element> &post) {
    stack<Element> s;
    for (auto it = post.begin(); it != post.end(); it++) {
        if (it->isData()) {
            s.push(*it);
        } else if (it->isOp()) {
            double op_2 = s.top().getValue();
            s.pop();
            double op_1 = s.top().getValue();
            s.pop();
            char op = it->getOp();
            if (op == '+') {
                s.push(Element::MakeData(op_1 + op_2));
            } else if (op == '-') {
                s.push(Element::MakeData(op_1 - op_2));
            } else if (op == '*') {
                s.push(Element::MakeData(op_1 * op_2));
            } else if (op == '/') {
                s.push(Element::MakeData(op_1 / op_2));
            }
        }
    }
    return s.top().getValue();
}

double calc(const std::string &input) {
    return calc_post(mid2post(str2mid(input)));
}