简易科学计算器的设计

项目描述：嵌入式数据结构开发实训项目，独立完成简易科学计算器的设计；实现正负数的加、减、乘、除，支持欧拉数e、圆周率π(pi)、求幂符号^、阶乘！、正弦sin、余弦cos、正切tan、以10为底的对数函数lg、以欧拉数e为底的对数函数ln，输入表达式，能够得出结果；熟练掌握结构体、指针、栈的使用。

项目代码：

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

#define MAX_TOKEN_LEN 100   //标记最大长度
#define EXPR_INCREMENT 20   //表达式长度的增量

//栈元素类型
typedef struct
{
    double opnd;  //操作数
    char optr[11];  //运算符
    int flag;     //若为1，则是单目运算符；若为2，则是双目运算符
}SElemType;

//栈
typedef struct SNode
{
    SElemType data;
    struct SNode *next;
}SNode, *Stack;

//用来存储一个操作数或运算符
struct
{
    char str[MAX_TOKEN_LEN];
    int type;   //若为0,则是操作数；若为1，则是运算符
}token;

//用来存储表达式
struct
{
    char *str;
    int cur;  //标记读取表达式的当前位置
}expr;

Stack OPND,OPTR;  //操作数栈operand, 运算符栈operator
int expr_size;      //表达式长度

//初始化栈
void InitStack(Stack *s)
{
    *s = (Stack)malloc(sizeof(SNode));
    if (NULL == *s)
    {
        printf("动态内存申请失败.\n");
        exit(0);
    }
    (*s)->next = NULL;
}

//销毁栈
void DestroyStack(Stack *s)
{
    SNode *p;
    while (p = (*s))
    {
        (*s) = p->next;
        free(p);
    }
}

//入栈
void Push(Stack s, SElemType e)
{
    SNode *p;
    p = (SNode *)malloc(sizeof(SNode));
    if (NULL == p)
    {
        printf("动态内存申请失败.\n");
        exit(0);
    }
    strcpy(p->data.optr,e.optr);
    p->data.opnd = e.opnd;
    p->data.flag = e.flag;
    p->next = s->next;
    s->next = p;
    
}

//出栈
void Pop(Stack s, SElemType *e)
{
    SNode *p;
    p = s->next;
    if (NULL == p)
    {
        printf("栈为空，不能出栈.\n");
        exit(0);
    }
    s->next = p->next;
    strcpy(e->optr,p->data.optr);
    e->opnd = p->data.opnd;
    e->flag = p->data.flag;
    free(p);
}

//获取表达式字符串expr
void get_expr()
{
    char *p;
    int size;
    expr.cur = 0;
    expr_size = 100;
    expr.str = (char *)malloc(expr_size * sizeof(char));
    if (NULL == expr.str)
    {
        printf("动态内存申请失败.\n");
        exit(0);
    }
    size = 0;
    p = expr.str;
    while ((*p = getchar()) != '\n')
    {
        if (*p != ' ')
        {
            if ((*p >= 'A') && (*p <= 'Z'))
            {
                *p = *p + 'a' - 'A'; //将大写字母转换成小写字母
            }
            p++;
            size++;
            if (size == expr_size - 1) //若expr.str已满，则将其扩大
            {
                expr_size += EXPR_INCREMENT;
                expr.str = (char *)realloc(expr.str,expr_size * sizeof(char));
                if (NULL == expr.str)
                {
                    printf("内存申请失败.\n");
                    exit(0);
                }
                p = &expr.str[size]; //realloc后需要重新指定p    
            }
        }
    }
    *p++ = '#';
    *p = '\0';
}

//判断ch是否为操作数的一部分
int IsOpnd(char ch)
{
    if (((ch >= '0') && (ch <= '9')) || (ch == '.'))
    {
        return 1;
    }
    if ((ch == '-') || (ch == '+'))  //如若+-前面是'#'或'('，则为正负号
    {
        if ((expr.cur == 0) || (expr.str[expr.cur - 1] == '('))
        {
            return 1;
        }
    }
    return 0;
}

//获取一个标记
void gettoken()
{
    char *p = token.str;
    *p = expr.str[expr.cur];
    if (0 != IsOpnd(*p))
    {
        while (IsOpnd(*++p = expr.str[++expr.cur]))
            ;
        *p = '\0';
        token.type = 0;  //将标记类型设定为操作数
        return;    
    }
    if ((*p >= 'a') && (*p <= 'z')) //接收sin,tan,ln之类的函数运算符或者操作数
    {
        while ((expr.str[expr.cur + 1] >= 'a') && (expr.str[expr.cur + 1] <= 'z'))
        {
            *++p = expr.str[++expr.cur];
        }
    }
    ++expr.cur;
    *++p = '\0';
    if (!strcmp(token.str,"e"))  //e为欧拉数，即自然对数的底数
    {
        sprintf(token.str,"%.16g",exp(1)); 
        token.type = 0;
        return;
    }
    if (!strcmp(token.str,"pi")) //pi为圆周率
    {
        strcpy(token.str,"3.14159265358997932");
        token.type = 0;
        return;
    }
    token.type = 1;  //将标记类型设定为运算符
}

//返回优先关系
char Precede(SElemType *optr1, SElemType *optr2)
{
    char *str1, *str2;
    str1 = optr1->optr;
    str2 = optr2->optr;
    if (!strcmp(str1,"ln") || !strcmp(str1,"lg") || !strcmp(str1,"sin") || !strcmp(str1,"cos") || !strcmp(str1,"tan"))
    {
        optr1->flag = 1;  //这些为单目运算符
        return (!strcmp(str2,"(") || !strcmp(str2,"^") || !strcmp(str2,"!")) ? '<' : '>';
    }
    if (!strcmp(str1,"!"))
    {
        optr1->flag = 1;
        return '>';
    }
    optr1->flag = 2;
    switch (str1[0])
    {
    case '+':
    case '-':
        return (!strcmp(str2,"+") || !strcmp(str2,"-") || !strcmp(str2,")") || !strcmp(str2,"#")) ? '>' : '<';
    case '*':
    case '/':
        return (!strcmp(str2,"+") || !strcmp(str2,"-") || !strcmp(str2,"*") || !strcmp(str2,"/") || !strcmp(str2,")") || !strcmp(str2,"#")) ? '>' : '<';
    case '(':
        return !strcmp(str2,")") ? '=' : '<';
    case ')':
        return '>';
    case '^':
        return (!strcmp(str2,"(") || !strcmp(str2,"!") || !strcmp(str2,"^")) ? '>' : '<';
    case '#':
        return !strcmp(str2,")") ? '=' : '<';
    }

    return 0;
}

//阶乘
long factorial(long n)
{
    return (n <= 1) ? 1 : n * factorial(n - 1);
}

//计算
SElemType Operate(SElemType opnd1, SElemType optr, SElemType opnd2)
{
    SElemType temp;
    if (optr.flag == 1)
    {
        if (!strcmp(optr.optr,"!"))
            temp.opnd = factorial((long)opnd2.opnd);
        else if (!strcmp(optr.optr,"lg"))
            temp.opnd = log10(opnd2.opnd);
        else if (!strcmp(optr.optr,"ln"))
            temp.opnd = log(opnd2.opnd);
        else if (!strcmp(optr.optr,"sin"))
            temp.opnd = sin(opnd2.opnd);
        else if (!strcmp(optr.optr,"cos"))
            temp.opnd = cos(opnd2.opnd);
        else if (!strcmp(optr.optr,"tan"))
            temp.opnd = tan(opnd2.opnd);
        return temp;        
    }
    
    switch (optr.optr[0])
    {
    case '+':
        temp.opnd = opnd1.opnd + opnd2.opnd;
        break;
    case '-':
        temp.opnd = opnd1.opnd - opnd2.opnd;
        break;
    case '*':
        temp.opnd = opnd1.opnd * opnd2.opnd;
        break;
    case '/':
        temp.opnd = opnd1.opnd / opnd2.opnd;
        break;
    case '^':
        temp.opnd = pow(opnd1.opnd, opnd2.opnd);
    }
    return temp;
}

int main()
{
    SElemType optr, opnd1, opnd2;

    printf("\n欢迎使用简易科学计算器\n");
    printf("欧拉数为e,圆周率为pi,退出则输入quit\n");
    printf("优先级:括号 > ! > ^ > lg,ln,sin,cos,tan > *,/ > +,-\n");
    printf("请输入计算表达式:\n\n");

    while (1)
    {
        get_expr();
        if (!strcmp(expr.str,"quit#"))
        {
            return 0;
        }
    
        InitStack(&OPTR);
        InitStack(&OPND);
        strcpy(optr.optr, "#");
        Push(OPTR, optr);
        gettoken();
        while (strcmp(token.str, "#") || strcmp(OPTR->next->data.optr, "#"))
        {
            if (token.type)
            {
                strcpy(optr.optr, token.str);
                switch (Precede(&(OPTR->next->data), &optr))
                {
                case '<':
                    strcpy(optr.optr, token.str);
                    Push(OPTR, optr);
                    gettoken();
                    break;
                case '=':
                    Pop(OPTR, &optr);
                    gettoken();
                    break;
                case '>':
                    Pop(OPTR, &optr);
                    Pop(OPND, &opnd2);
                    if (optr.flag == 2)
                    {
                        Pop(OPND, &opnd1);
                    }
                    Push(OPND, Operate(opnd1,optr, opnd2));
                }
            }
            else
            {
                opnd1.opnd = atof(token.str);
                Push(OPND, opnd1);
                gettoken();
            }
        }
        printf("%.16g\n\n", OPND->next->data.opnd);
        free(expr.str);
        DestroyStack(&OPND);
        DestroyStack(&OPTR);
    }
    free(expr.str);
    return 0;
}