表达式求值（简易版）

昨天在复习数据结构之栈的时候，就想起自己以前帮同学做过一个表达式求值的，但现在想想基本忘光了，所以重新写过一个。现在这个版本的实现了

基本四则运算以及带括号的运算，并且支持括号的嵌套，如 5+((1+2)*3)+((1+2)*(2+3))这样的表达式。也支持输入的数字是多位的，而不仅仅是个

位数的运算，如 56+21这样的表达式。当然，因为这只是个初级版本，目前只支持整数的运算，而且当做除法时只会结果取整。而且这个程序也没有

进行一些异常处理（留到以后完善版解决）。对于非法输入也没有做处理，所有在测试的时候必须得按程序要求输入才能有正确结果（输入=就输出运

算结果）。下面是代码

#include<iostream>
using namespace std;

struct StackTR //运算符栈
{
        char ch[100];
        int top;
};

struct StackND //操作数栈
{
        int ch[100];
        int top;
};

void InitStack(StackTR* S)
{
        S->top = -1;
}

void Push(StackTR* S, char n)
{
        S->top++;
        S->ch[S->top] = n;
}

void Pop(StackTR* S, char* n)
{
        *n = S->ch[S->top];
        S->top--;
}

char GetTop(StackTR* S)
{
        return S->ch[S->top];
}

void InitStack(StackND* S)
{
        S->top = -1;
}

void Push(StackND* S, int n)
{
        S->top++;
        S->ch[S->top] = n;
}

void Pop(StackND* S, int* n)
{
        *n = S->ch[S->top];
        S->top--;
}

int GetTop(StackND* S)
{
        return S->ch[S->top];
}

int Operate(int a, char op, int b) //对操作数进行运算
{
        switch (op)
        {
        case '+':
                        return a+b;
                        break;
        case '-':
                        return a-b;
                        break;
        case '*':
                        return a*b;
                        break;
        case '/':
                        return a/b;
                        break;
        default:
                        break;
        }
}

char Precede(char a, char b)//运算符优先级的判断
{
        if (a == '=')
        {
                if (b == '=')
                        return '>';
                return '<';
        }
        if (a == '(')
        {
                if (b == '=')
                        return '>';
                if (b == ')')
                return '=';
                else
                return '<';
        }
        if (a == '+' || a == '-')
        {
                if (b == '=')
                        return '>';
                if (b == ')')
                        return '>';
                else if (b == '+' || b == '-')
                        return '>';
                else
                        return '<';
        }
        if (a == '*' || a == '/')
        {
                if (b == '(')
                        return '<';
                return '>';
        }
}

int main()
{
        StackTR tr;
        StackND nd;
        int result;
        char c;
        bool judge = false;
        InitStack(&tr);
        InitStack(&nd);
        Push(&tr, '=');
        c = getchar();
        while(c != '=' || GetTop(&tr) != '=')
        {   
                if (c >= '0' && c <= '9') //处理输入数字字符的情况
                {
                        if (judge) //当连续输入多个数字字符时，先从数字栈栈顶读取操作数，然后乘以10加上新输入的数字，再入栈
                        {
                                int x;
                                Pop(&nd, &x);
                                x = x * 10 + (c - '0');
                                Push(&nd, x);
                        }
                        else
                        Push(&nd, (c - '0'));
                        judge = true;
                        c = getchar();
                        continue;
                }
                judge = false;
                switch(Precede(GetTop(&tr), c))
                {
                case '<': 
                                Push(&tr, c);
                                c = getchar();
                                break;
                case '=': 
                                char y;
                                Pop(&tr, &y);
                                c = getchar();
                                break;
                case '>':
                                char op;
                                int a, b;
                                Pop(&tr, &op);
                                Pop(&nd, &b);
                                Pop(&nd, &a);
                                Push(&nd, Operate(a, op, b));
                                break;
                default:
                                break;
                }
        }
        Pop(&nd, &result);
        cout << result << endl;
        system("pause");
        return 0;
}