计算器

#include<iostream>
#include<cstring>
#include<stdlib.h>
#include<cstdio>
using namespace std;


#define Selemtype char
int const stack_initsize = 100;
int const stackincrement = 10;


typedef struct
{
    Selemtype *elem;
    int top;
    int stacksize;
    int incrementsize;
}Sqstack;


typedef struct
{
    double *elem;
    int top;
    int stacksize;
    int incrementsize;
}Sqnumstack;


void creatstack(Sqstack &S, int maxsize = stack_initsize, int incresize = stackincrement)
{
    //创建一个空栈
    S.elem = new Selemtype[maxsize];
    S.top = -1;
    S.stacksize = maxsize;
    S.incrementsize = incresize;
}


void incrementstack(Sqstack &S)
{
    //扩大空间
    Selemtype *a;
    a = new Selemtype [S.stacksize + S.incrementsize];
    for(int i = 0; i < S.top; i++)
        a[i] = S.elem[i];
    delete[] S.elem;
    S.elem = a;
    S.stacksize += S.incrementsize;
}


int Slength(Sqstack &S)
{
    //返回栈的长度
    return S.top;
}


void Sclear(Sqstack &S)
{
    //清空栈
    while(S.top != -1)
    {
        S.elem[S.top--] = 0;
    }
    delete[] S.elem;
}
bool gettop_sq(Sqstack &S, Selemtype &e)
{
    //若栈不空，用e返回栈顶元素，并返回true，否则返回false
    if(S.top == -1)
        return false;
    e = S.elem[S.top];
    return true;
}


void push_sq(Sqstack &S, Selemtype e)
{
    //插入元素e到栈顶
    if(S.top == S.stacksize-1)
        incrementstack(S);
    S.elem[++S.top] = e;
}


bool pop_sq(Sqstack &S, Selemtype &e)
{
    //若栈不空，删除栈顶元素，用e返回，并返回TRUE，否则返回FALSE
    if(S.top == -1)
        return false ;
    e = S.elem[S.top--];
    return true;
}


bool Sempty(Sqstack &S)
{
    //判断是否为空
    if(S.top == -1)
        return true;
    else return false;
}


void creatnumstack(Sqnumstack &S, int maxsize = stack_initsize, int incresize = stackincrement)
{
    //创建一个空栈
    S.elem = new double[maxsize];
    S.top = -1;
    S.stacksize = maxsize;
    S.incrementsize = incresize;
}


void incrementnumstack(Sqnumstack &S)
{
    //扩大空间
    double *a;
    a = new double [S.stacksize + S.incrementsize];
    for(int i = 0; i < S.top; i++)
        a[i] = S.elem[i];
    delete[] S.elem;
    S.elem = a;
    S.stacksize += S.incrementsize;
}


int Slength(Sqnumstack &S)
{
    //返回栈的长度
    return S.top;
}


void Sclear(Sqnumstack &S)
{
    //清空栈
    while(S.top != -1)
    {
        S.elem[S.top--] = 0;
    }
    delete[] S.elem;
}
bool gettop_nsq(Sqnumstack &S, double &e)
{
    //若栈不空，用e返回栈顶元素，并返回true，否则返回false
    if(S.top == -1)
        return false;
    e = S.elem[S.top];
    return true;
}


void push_nsq(Sqnumstack &S, double e)
{
    //插入元素e到栈顶
    if(S.top == S.stacksize-1)
        incrementnumstack(S);
    S.elem[++S.top] = e;
}


bool pop_nsq(Sqnumstack &S, double &e)
{
    //若栈不空，删除栈顶元素，用e返回，并返回TRUE，否则返回FALSE
    if(S.top == -1)
        return false ;
    e = S.elem[S.top--];
    return true;
}


bool Snempty(Sqnumstack &S)
{
    //判断是否为空
    if(S.top == -1)
        return true;
    else return false;
}
//---------------------------------------------------------------------------------------
//表达式求值


bool precede(char c, char ch)
{
    //判断符号的优先级
    if((c == '*' || c == '/') && (ch == '+' || ch == '-') )
        return true;
    else return false;
}


bool opmember(char ch)
{
    //若ch为运算符，则返回true，否则返回false
    if(ch == '+' || ch == '-' || ch == '*' || ch == '/')
        return true;
    else return false;
}


void transform(char *suffix, char *exp)
{
    //从合法表达式字符串exp求得相应的后缀表达式suffix
    Sqstack S2;
    creatstack(S2, 100, 10);
    push_sq(S2, '#');
    Selemtype *p, ch, c;
    p = exp;
    ch = *p;
    int k = 0;


    while(!Sempty(S2))
    {
        //cout<<"1"<<endl;
        if(!opmember(ch))
            suffix[k++] = ch;
        else
        {
            switch(ch)
            {
            case'(':
                push_sq(S2, ch);
                break;
            case')':
                {
                    pop_sq(S2, c);
                    while(c!='(')
                    {
                        suffix[k++] = c;
                        pop_sq(S2, c);
                    }
                }
            default:
                {
                    while(gettop_sq(S2, c) && precede(c, ch))
                    {
                        suffix[k++] = c;
                        pop_sq(S2, c);
                    }
                    if(ch != '#')
                        push_sq(S2, ch);
                    break;
                }
            }
        }
        if(ch != '#')
            ch = *++p;
    }
    suffix[k] = '\0';
    /*for(int i = 0; i < k; i++)
        cout<<suffix[i];
    cout<<endl;*/
}


double operate(double a, char ch, double b)
{
    //计算a ch b 的结果
    switch(ch)
    {
    case'+':
        return a+b;
    case'-':
        return a-b;
    case'*':
        return a*b;
    case'/':
        {
            if(b != 0)
                return a/b;
            else
                cout<<"error!"<<endl;
            break;
        }
    }


}


double evaluation(char suffix[])
{
    //返回后缀表达式suffix的运算结果
    Sqnumstack S1;
    Selemtype ch = *suffix++;
    double a, b, c = 0;
    creatnumstack(S1, 100, 10);
    double result;
    int i = 1;


    while(ch != '#')
    {
        if(!opmember(ch))
        {
            while(!opmember(ch))
            {
                c = i * (ch-48);
                i++;
                ch = *suffix++;
            }
            push_nsq(S1, c);
        }
        else
        {
            pop_nsq(S1, b);
            pop_nsq(S1, a);
            push_nsq(S1, operate(a, ch, b));
        }
        ch = *suffix++;
    }
    pop_nsq(S1, result);
    return result;
}


int main()
{
    //输入运算式， 计算结果
    char exp[1000], suffix[1000];


    cout<<"please input the expression: ";
    while(cin>>exp)
    {
        memset(suffix,0,sizeof(suffix));
        int len=strlen(exp);
        exp[len]='#';
        transform(suffix, exp);
        cout<<"the result is:";
        cout<<evaluation(suffix)<<endl;
    }
    return 0;
}