采用进出栈方式设计简单计算器

#include<stdio.h>
#include<math.h>
#include<stdlib.h>

typedef struct stack1 {
    char data[20];
    int top;
} StackChars;

typedef struct stack2 {
    double data[20];
    int top;
} StackDatas;

double calculator(char str[100]);
char getUnary(char str[20], int * key);
int getLevel(char a);
void InitStackdata(StackDatas* sdt);
void InitStackchar(StackChars* stc);
void Pushd(StackDatas* stc, double x);
void Pushc(StackChars* stc, char x);
void Popd(StackDatas* sdt, double * y);
void Popc(StackChars* sdt, char * y);
void cal(StackDatas* sdt, char a);
double toData(char str[20], int* key);
int stackIn(char a, char top);

double calculator(char str[100]) {
    StackChars stackCh;
    StackDatas stackDa;
    InitStackdata(&stackDa);
    InitStackchar(&stackCh);
    Pushc(&stackCh, '=');
    int i = 0, sign = 1;/*sign标记是否是表达式最开始*/

    while (str[i] != '='&&str[i]) {
        while (str[i] == ' ')i++;
        if (sign && (str[i] == '+' || str[i] == '-'))
        {
            Pushd(&stackDa, 0);/*处理表达式或（后直接带的第一个正负号*/
        }
        if (str[i] >= '0'&&str[i] <= '9' || str[i] == '.')
        {
            Pushd(&stackDa, toData(str, &i));/*把字符转化操作数，并放入对应栈中*/
            sign = 0;
            while (str[i] == ' ')i++;
        }
        else if (str[i] >= 'a'&&str[i] <= 'z')
        {
            Pushc(&stackCh, getUnary(str, &i));/*单目运算符（不含括号）可直接放入栈中*/
            while (str[i] == ' ')i++;
        }
        else if (str[i] == ')') {
            char x = '!';
            while (stackCh.data[stackCh.top] != '(') {/*用括号中的操作符运算*/
                Popc(&stackCh, &x);
                cal(&stackDa, x);
            }
            Popc(&stackCh, &x);/*删掉（不运算*/
            i++;
            while (str[i] == ' ')i++;
        }
        else {
            if (str[i] == '(')
                sign = 1;
            if (stackIn(str[i], stackCh.data[stackCh.top]))
                Pushc(&stackCh, str[i]);
            else {
                int stop = 0, cur = stackCh.top;
                while (!stop)
                {
                    stackCh.top--;
                    cal(&stackDa, stackCh.data[cur]);
                    cur--;
                    stop = stackIn(str[i], stackCh.data[cur]);
                }
                Pushc(&stackCh, str[i]);
            }
            i++;
        }
    }
    char x;
    double result;
    while (stackCh.data[stackCh.top] != '=') {

        Popc(&stackCh, &x);
        cal(&stackDa, x);
    }
    Popc(&stackCh, &x);
    Popd(&stackDa, &result);
    return result;
}

char getUnary(char str[20], int * key) {
    char unary[6];/*记录单目运算符*/
    int j = 0;
    while (str[*key] >= 'a'&&str[*key] <= 'z')
    {
        unary[j++] = str[*key];
        (*key)++;
    }
    unary[j] = '\0';
    if (strcmp(unary, "sin") == 0)return 's';
    else if (strcmp(unary, "cos") == 0) return 'c';
    else if (strcmp(unary, "log") == 0) return 'o';
    else { if (strcmp(unary, "ln") == 0) return 'n'; }

}

int getLevel(char a) {/*得到操作符优先级，除了操作符外其他字符返回-1，对于数字和'.'的判断不用此函数*/
    switch (a) {
    case'=':return 0;
    case'+':return 1;
    case'-':return 1;
    case'*':return 2;
    case'/':return 2;
    case'^':return 2;
    case's':return 3;/*sin*/
    case 'c':return 3;/*cos*/
    case'o':return 3;/*log*/
    case'n':return 3;/*ln*/
    case'(':return 4;/*'('进入栈前为最大4，进入栈后为最小0*/
    default:return -1;
    }
}

void InitStackdata(StackDatas* sdt) {
    (*sdt).top = -1;
}

void InitStackchar(StackChars* stc) {
    (*stc).top = -1;
}

void Pushd(StackDatas* stc, double x) {
    (*stc).top++;
    (*stc).data[(*stc).top] = x;
}

void Pushc(StackChars* stc, char x) {
    (*stc).top++;
    (*stc).data[(*stc).top] = x;
}

void Popd(StackDatas* sdt, double * y) {
    *y = (*sdt).data[(*sdt).top];
    (*sdt).top--;
}

void Popc(StackChars* sdt, char * y) {
    *y = (*sdt).data[(*sdt).top];
    (*sdt).top--;
}


void cal(StackDatas* sdt, char a) {
    double top1 = (*sdt).data[(*sdt).top];
    double top2 = (*sdt).data[(*sdt).top - 1];
    double result = 0.0;
    switch (a) {
    case'+':result = top1 + top2;
        (*sdt).top--;
        break;
    case'-':result = top2 - top1;
        (*sdt).top--;
        break;
    case'*':result = top2 * top1;
        (*sdt).top--;
        break;
    case'/':result = top2 / top1;
        (*sdt).top--;
        break;
    case'^':result = pow(top2, top1);
        (*sdt).top--;
        break;
    case's':/*sin*/
        result = sin(top1);
        break;
    case 'c':/*cos*/
        result = cos(top1);
        break;
    case'o':/*log*/
        result = log10(top1);
        break;
    case'n':/*ln*/
        result = log(top1);
        break;
    }
    (*sdt).data[(*sdt).top] = result;
}

double toData(char str[20], int* key) {
    char rel[20] = { '\0' };
    int i = 0;
    while (str[*key] >= '0'&&str[*key] <= '9' || str[*key] == '.') {
        rel[i] = str[*key];
        i++;
        (*key)++;
    }
    rel[i] = '\0';
    return atof(rel);
}

int stackIn(char a, char top) {/*返回1 a可直接进栈*/
    int x = getLevel(a);
    int y = getLevel(top);
    if (top == '(')/*栈内（为0*/
        y = 0;
    if (x <= y)
        return 0;/*a不能直接进栈*/
    else
        return 1;
}



int main() {
    char str[100];
    while (1) {//这个我直接按叉号结束程序，有更好方法可以改
        gets(str);
        printf("%.4f \n", calculator(str));//按保留小数点后4位，可修改
    }

    system("pause");
}