简单算术表达式C++实现

输入的算术表达式是中缀表达式，由于操作符的优先级不同，不能直接进行求解，而后缀表达式的计算不需要判别操作符的优先级，所以我实现算术表达式的思路是：1）应用堆栈将中缀表达式转化为后缀表达式，2）用堆栈实现后缀表达式求值。
用堆栈实现后缀表达式求值的过程：从左到右读入后缀表达式的各项，并根据读入的对象判断执行何种操作，有以下3中情况：
1) 当读入的是一个运算数时，把它压入栈中；
2) 当读入的是一个运算符时，就从栈中弹出适当数量的运算数并进行计算，计算结果再压回到栈中；
3) 处理完整个后缀表达式之后，栈顶上的元素就是表达式的结果。
应用堆栈将中缀表达式转换为后缀表达式的基本过程为：从头到尾读取中缀表达式的每个对象，对不同对象按不同情况处理：
1) 如果遇到空格则认为是分隔符，无需处理；
2) 若遇到运算数，则直接输出；
3) 若是左括号，则将其压入至栈中；
4) 若遇到的是右括号，表明括号内的中缀表达式已经扫描完毕，将栈顶的运算符弹出并输出，直到遇到左括号（左括号也出栈，但不输出）；
5) 若遇到的是运算符，若该运算符的优先级大于栈顶运算符的优先级，则把它压入栈中；若该运算符的优先级小于等于栈顶运算符时，将栈顶运算符弹出并输出，在比较新的栈顶运算符，按这样的处理方法，直到该运算符大于栈顶运算符优先级为止，然后将该运算符压栈；
6) 若中缀表达式中的各对象处理完毕，则把堆栈中保留的运算符一并输出。
在代码实现的过程中，首先我们要定义一个栈，因为在后缀表达式求值的过程中，栈是用来存运算数的；在中缀转换为后缀表达式的过程中，栈是用来存放操作符的。所以在实现栈的时候我用了模板。栈的实现如下：
// Stack.h

#include<vector>template <class T>class Stack{public:    void push(const T&);    T pop();    T peek();//该函数只是返回最顶端的元素，并不删除    bool empty();private:    std::vector<T> _stack;};template<class T>void Stack<T>::push(const T& a){    _stack.push_back(a);}template<class T>T Stack<T>::pop(){    //在要用到出栈的时候一定要保证栈不为空    auto it = _stack.end();    auto c = *(it - 1);    _stack.pop_back();    return c;}template<class T>bool Stack<T>::empty(){    return _stack.begin() == _stack.end();}template<class T>T Stack<T>::peek(){    auto it = _stack.end();    return *(it - 1);}

定义相应的运算符的优先级，我用整数的大小来定义优先级的大小，对应的函数实现如下：

int op_pri(const char& a){    switch (a){    case ')':        return 0;    case '+':case '-':        return 1;    case '*':case'/':        return 2;    case '(':        return 3;    }}

在实现优先级的时候，当输入为左括号时，需要无条件进栈，所以左括号的优先级要最高。碰到右括号时要无条件出栈直到那个栈顶的操作符是左括号。所以右括号的优先级我定义为最低。但是要注意当当前的运算符为右括号时，证明括号内的中缀表达式已经扫描完毕，要将栈顶运算符弹出，直到左括号（这时左括号出栈，但是不用加入到运算中）；还要注意当运算符是左括号时，因为我把左括号定义为了最高优先级了，如果按正常的情况，当栈顶是左括号时，应当会马上输出但是这不符合我们的要求，希望的是紧接的运算符能无条件的入栈，所以在代码的实现过程中这是中特殊的情况用个if语句强调。
接下来是对中缀转换为后缀表达式实现的最主要的功能函数，就是运算符的出入栈的情况：

int oper_cp(const char&a, const char& b){    int c = op_pri(a);    int d = op_pri(b);    if (c == 0 && d == 3)        return -1;//当左括号碰到右括号时，定义为一个特殊状态，此状态是直接把栈中的左括号操作符弹出    //右括号也不进栈    else if (d == 3)//定义优先级时，以整数大小来对应优先级的大小。但是当输入为左括号时，需要无条件        //进栈，所以左括号的优先级要最高。碰到右括号时要无条件出栈直到那个栈顶的操作符是左括号。所以        //右括号的优先级要最低。        //但是在右括号进栈后，若紧接的操作符是+、-、*、/的话，需要进栈，这个条件语句就是在这种情况下        //对应的操作符直接进栈        return 1;    else if (c > d){        return 1;    }    else        return 0;}

有了上述两个函数的支持，接下来就是直接对中缀表达式求值的函数，这些问题只是逻辑问题，我的代码实现如下：

void exp(Stack<double> &val, Stack<char> &op){    char c{};    string s{};    do    {        c = getchar();        if ((c >= '0'&&c <= '9') || c == '.')        {            s.push_back(c);            continue;        }        else        {            if (s != "\0")            {                val.push(atof(s.c_str()));                s = "\0";            }        }        if (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || c == '(')        {            char b;            if (op.empty()){                op.push(c);                continue;            }            while (1)            {                if (!op.empty())                    b = op.peek();                else                {                    op.push(c);                    break;                }                int m = oper_cp(c, b);                if (m == 1)                {                    op.push(c);                    break;                }                if (m == 0)                {                    b = op.pop();                    double c, d;                    d = val.pop();                    c = val.pop();                    switch (b)                    {                    case '+':                        val.push(c + d);                        break;                    case '-':                        val.push(c - d);                        break;                    case'*':                        val.push(c*d);                        break;                    case'/':                        val.push(c / d);                        break;                    }                    continue;                }                if (m == -1)                {                    op.pop();                    break;                }            }        }    } while (c != '\n');    while (!op.empty()){        char b = op.pop();        double e, d;        d = val.pop();        e = val.pop();        switch (b)        {        case '+':            val.push(e + d);            break;        case '-':            val.push(e - d);            break;        case'*':            val.push(e*d);            break;        case'/':            val.push(e / d);            break;        }    }}

调用这些函数的main函数如下：

#include<iostream>#include<string>#include "Stack.h"using namespace std;void exp(Stack<double> &val, Stack<char> &op);int op_pri(const char& );int oper_cp(const char&a, const char& b);int  main(){    Stack<double> val;    Stack<char> op;    exp(val, op);    cout << val.pop();}int oper_cp(const char&a, const char& b){    int c = op_pri(a);    int d = op_pri(b);    if (c == 0 && d == 3)        return -1;//当左括号碰到右括号时，定义为一个特殊状态，此状态是直接把栈中的左括号操作符弹出    //右括号也不进栈    else if (d == 3)//定义优先级时，以整数大小来对应优先级的大小。但是当输入为左括号时，需要无条件        //进栈，所以左括号的优先级要最高。碰到右括号时要无条件出栈直到那个栈顶的操作符是左括号。所以        //右括号的优先级要最低。        //但是在右括号进栈后，若紧接的操作符是+、-、*、/的话，需要进栈，这个条件语句就是在这种情况下        //对应的操作符直接进栈        return 1;    else if (c > d){        return 1;    }    else        return 0;}int op_pri(const char& a){    switch (a){    case ')':        return 0;    case '+':case '-':        return 1;    case '*':case'/':        return 2;    case '(':        return 3;    }}void exp(Stack<double> &val, Stack<char> &op){    char c{};    string s{};    do    {        c = getchar();        if ((c >= '0'&&c <= '9') || c == '.')        {            s.push_back(c);            continue;        }        else        {            if (s != "\0")            {                val.push(atof(s.c_str()));                s = "\0";            }        }        if (c == '+' || c == '-' || c == '*' || c == '/' || c == ')' || c == '(')        {            char b;            if (op.empty()){                op.push(c);                continue;            }            while (1)            {                if (!op.empty())                    b = op.peek();                else                {                    op.push(c);                    break;                }                int m = oper_cp(c, b);                if (m == 1)                {                    op.push(c);                    break;                }                if (m == 0)                {                    b = op.pop();                    double c, d;                    d = val.pop();                    c = val.pop();                    switch (b)                    {                    case '+':                        val.push(c + d);                        break;                    case '-':                        val.push(c - d);                        break;                    case'*':                        val.push(c*d);                        break;                    case'/':                        val.push(c / d);                        break;                    }                    continue;                }                if (m == -1)                {                    op.pop();                    break;                }            }        }    } while (c != '\n');    while (!op.empty()){        char b = op.pop();        double e, d;        d = val.pop();        e = val.pop();        switch (b)        {        case '+':            val.push(e + d);            break;        case '-':            val.push(e - d);            break;        case'*':            val.push(e*d);            break;        case'/':            val.push(e / d);            break;        }    }}