求下面内容程序的代码

Question

编写一个程序计算输入的四则运算式的结果（要用到函数）
输入：四则运算式
输出：结果
输入：3*[（3+5）/4]-2
输出：4

Answer 1

用栈来处理，运行结果如下：

代码：

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#define STACK_INIT_SIZE 1000 //存储空间初始分配量 
#define STACKINCREMENT 100 //分配增量
typedef int Status;
typedef char ElemType;
typedef int Datatype;  //数据类型
typedef struct {
    ElemType* base;
    ElemType* top;
    int stacksize;
}OPTRStack;
typedef struct {
    Datatype* base;
    Datatype* top;
    int stacksize;
}OPNDStack;
//定义幂函数
int pow_m(int a, int b)
{
    int s = 1;
    int i = 0;
    for (i = 0; i < b; i++)
        s *= a;
    return s;
}
Status InitStackOPTR(OPTRStack& s) {
    s.base = (ElemType*)malloc(STACK_INIT_SIZE * sizeof(ElemType));
    if (!s.base) {
        exit(1);
    }
    s.top = s.base;
    s.stacksize = STACK_INIT_SIZE;
    return 0;
}//
Status InitStackOPND(OPNDStack& s) {
    s.base = (Datatype*)malloc(STACK_INIT_SIZE * sizeof(Datatype));
    if (!s.base) {
        exit(1);
    }
    s.top = s.base;
    s.stacksize = STACK_INIT_SIZE;
    return 0;
}//
ElemType GetTopOPTR(OPTRStack s) {//获取栈顶元素 
    ElemType e;
    if (s.top == s.base) {
        return 0;
    }
    e = *(s.top - 1);
    return e;
}
Datatype GetTopOPND(OPNDStack s) {//获取栈顶元素 
    Datatype e;  //MOD  
    if (s.top == s.base) {
        return 0;
    }
    e = *(s.top - 1);
    return e;
}
 
void PushOPTR(OPTRStack& s, ElemType e) {//插入元素e为新的栈顶元素 
    if (s.top - s.base >= s.stacksize) {//如果栈满，扩充空间 
        s.base = (ElemType*)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(ElemType));
        if (!s.base) {
            exit(1);
        }
        s.top = s.base + s.stacksize;
        s.stacksize += STACKINCREMENT;
    }
    *s.top++ = e;//赋值后栈顶指针+1 
}
void PushOPND(OPNDStack& s, Datatype e) {//插入元素e为新的栈顶元素   
    if (s.top - s.base >= s.stacksize) {//如果栈满，扩充空间 
        s.base = (Datatype*)realloc(s.base, (s.stacksize + STACKINCREMENT) * sizeof(Datatype));
        if (!s.base) {
            exit(1);
        }
        s.top = s.base + s.stacksize;
        s.stacksize += STACKINCREMENT;
    }
    *s.top++ = e;//赋值后栈顶指针+1 
}
ElemType PopOPTR(OPTRStack& s) {//删除栈顶元素 
    ElemType e;
    if (s.top == s.base) {
        return 1;
    }
    e = *--s.top;//栈顶指针-1，给e赋值 
    return 0;
}
Status PopOPND(OPNDStack& s) {//删除栈顶元素 
    Datatype e;
    if (s.top == s.base) {
        return 1;
    }
    e = *--s.top;//栈顶指针-1，给e赋值 
    return 0;
}
Status In_sign(ElemType c) {
    if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')' || c == '[' || c == ']' || c == '^')
        return 1;
    else
        return 0;
}
Status In_Num(ElemType e) {
    if (e >= '0' && e <= '9')
        return 1;
    else
        return 0;
}
Status Precede(ElemType op) {//存储函数的优先级
    switch (op) {
    case'+':
    case'-':
        return 1;
    case'*':
    case'/':
        return 2;
    case'^':
        return 3;
    case'(':
    case'[':
        return 4;
    case')':
    case']':
        return 0;
    }
}
Status arity(ElemType x) {//存储运算符的元数
    switch (x) {
    case'+':
    case'-':
    case'*':
    case'/':
    case'^':
        return 2;
    case'(':
    case')':
    case'[':
    case']':
        return 0;
    }
}
Datatype Operate(Datatype a, ElemType x, Datatype b) {//进行运算的函数 
    if (arity(x) == 2) {
        switch (x) {
        case '+':
            return a + b;
        case '-':
            return a - b;
        case '*':
            return a * b;
        case '/':
            return a / b;
        case'^':
            return pow_m(a, b);
        }
    }
}//Operate
Status check(ElemType left, ElemType right) {
    if (left == '(' && right == ')')
        return 1;
    else if (left == '[' && right == ']')
        return 1;
    else
        return 0;
}//判断括号
Status emptyOPND(OPNDStack s) {
    if (s.top == s.base || s.top < s.base)
        return 0;
    else
        return 1;
}//判断栈是否为空
Status emptyOPTR(OPTRStack s) {
    if (s.top == s.base || s.top < s.base)
        return 0;
    else
        return 1;
}//判断栈是否为空
//计算一条表达式
int CaculateAll(char* s) {
    OPTRStack OPTR, BRACKETS;//OPTR:运算符栈 OPND:运算数栈 BRACKETS:括号栈
    OPNDStack OPND;
    ElemType theta;
    InitStackOPTR(OPTR);
    InitStackOPND(OPND);
    InitStackOPTR(BRACKETS);
    Status len, n;
    len = strlen(s);
    s[len] = '#';
    len++;
    Status i;
    Datatype a, b, c = 0;
    for (i = 0; i < len; i++) {
        if (s[i] == '(' || s[i] == '[') {
            PushOPTR(BRACKETS, s[i]);
        }
        else if (s[i] == ')' || s[i] == ']') {
            if (check(GetTopOPTR(BRACKETS), s[i]) == 1) {
                PopOPTR(BRACKETS);
            }
            else
            {
                //printf("ERROR_02"); //括号不匹配
                return 0;
            }
        }
    }//判断括号是否匹配
    for (i = 0; i < len - 1; i++) {
        if (In_sign(s[i]) == 0 && In_Num(s[i]) == 0 && s[i] != '.') {
            //printf("ERROR_02"); //输入非法
            return 0;
        }//判断是否是数字和运算符号
    }
    i = 0;
    if (s[0] == '+' || s[0] == '-' || s[0] == '*' || s[0] == '/' || s[0] == '^' /* || s[0] == '.'*/) {
        //printf("ERROR_02");
        return 0;
    }
    while (s[i] != '#') {
        Datatype x = 0;
        if (In_Num(s[i]) == 1) {
            while (s[i] >= '0' && s[i] <= '9') {
                x *= 10;
                x += s[i++] - '0';
            }
            /*if (s[i] == '.') {  //小数部分
                double d = 0.1;
                i++;
                while (s[i] >= '0' && s[i] <= '9') {
                    x += ((s[i] - '0') * d);
                    d *= 0.1;
                    i++;
                }
            }*/
            PushOPND(OPND, x);
            continue;
        }
        else {
            ElemType theta = s[i];
            while (emptyOPTR(OPTR) == 1 && Precede(GetTopOPTR(OPTR)) >= Precede(s[i])) {
                if (arity(GetTopOPTR(OPTR)) == 2) {
                    a = GetTopOPND(OPND);
                    PopOPND(OPND);
                    b = GetTopOPND(OPND);
                    PopOPND(OPND);
                    if (a == 0 && GetTopOPTR(OPTR) == '/')
                    {
                        printf("INVALID\n");
                        return 0;
                    }
                    c = Operate(b, GetTopOPTR(OPTR), a);
                    PushOPND(OPND, c);
                    PopOPTR(OPTR);
                }
                else {
                    break;
                }
            }
            if (Precede(theta) == 0 && Precede(GetTopOPTR(OPTR)) == 4) {
                PopOPTR(OPTR);
            }
            if (Precede(theta) != 0) {
                PushOPTR(OPTR, theta);
            }
            i++;
        }
    }
    while (emptyOPTR(OPTR) == 1) {
        a = GetTopOPND(OPND);
        PopOPND(OPND);
        b = GetTopOPND(OPND);
        PopOPND(OPND);
        if (a == 0 && GetTopOPTR(OPTR) == '/')
        {
            printf("INVALID\n");
            return 0;
        }
        c = Operate(b, GetTopOPTR(OPTR), a);
        PushOPND(OPND, c);
        PopOPTR(OPTR);
    }
    printf("%d\n", GetTopOPND(OPND));
    return 1;
}
int main()
{
    char all[100] = { 0 }; //保存所有的公式 ，长度根据需要调整
    scanf("%s", all);
    CaculateAll(all);
    return 0;
}