C语言————栈实现简单计算器

1、搞两个栈

2、干起来

3、熬夜秃头

4、健壮性还有提高空间

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <string.h>
#define MAX 50


//操作符基本操作
typedef struct s
{
	char* s_data;
	int top;
}Stack_s;

//初始化操作符栈
Stack_s* InitStack_s()
{
	Stack_s* s=(Stack_s*)malloc(sizeof(Stack_s));
	s->s_data=(char*)malloc(sizeof(char)*MAX);
	s->top=-1;
	return s;
}

//操作符入栈
void push_ops(Stack_s* ops,char x)
{
	if(ops->top==MAX-1)
	{
		printf("运算符栈满\n");
		exit(0);
	}
	else
	{
		ops->s_data[++ops->top]=x;
	}
}

//操作符出栈
char pop_ops(Stack_s* ops)
{
	char arr;
	if(ops->top==-1)
	{
		printf("2输入有误\n");
		exit(0);
	}
	else
	{
		arr=ops->s_data[ops->top--];
	}
	return arr;
}

//获取操作符栈的栈顶元素
char gettop_ops(Stack_s* ops)
{
	if(ops->top!=-1)
	{
		return ops->s_data[ops->top];
	}
	else
	{
		printf("输入有误opsget\n");
		exit(0);
	}
}



typedef struct n
{
	double* s_data;
	int top;
}Stack_n;

//初始化操作数栈
Stack_n* InitStack_n()
{
	Stack_n* s=(Stack_n*)malloc(sizeof(Stack_n));
	s->s_data=(double*)malloc(sizeof(double)*MAX);
	s->top=-1;
	return s;
}

//操作数入栈
void push_ovs(Stack_n* ovs,double x)
{
	if(ovs->top==MAX-1)
	{
		printf("运算符栈满\n");
		exit(0);
	}
	else
	{
		ovs->s_data[++ovs->top]=x;
	}
}

//操作数出栈
double pop_ovs(Stack_n* ovs)
{
	double num;
	if(ovs->top==-1)
	{
		printf("1输入有误\n");
		exit(0);
	}
	else
	{
		num=ovs->s_data[ovs->top--];
	}
	return num;
}

//获取操作数栈的栈顶元素
double gettop_ovs(Stack_n* ovs)
{
	if(ovs->top!=-1)
	{
		return ovs->s_data[ovs->top];
	}
	else
	{
		printf("输入有误ovsget\n");
		exit(0);
	}
}





int Judge_ops(char t1,char t2)
{
    switch(t1)
    {
        case '+':
        case '-':
            if(t2=='+'||t2=='-')
                return 1;
            else
                return 0;
        case '*':
        case '/': return 1;
        case '(' :return 0;
    }
    return 1;
}


int Is_ops(char e)
{
    switch(e)
    {
        case '+':
        case '-':
        case '*':
        case '/':return 1;
        case '(':return 2;
        case ')':return -1;
        default :return 0;      //数字（包括'.'）
    }
}


//判断算数表达式是否正确
void judge(char e[MAX])
{
    int i=1;
    while(e[i]!='\0')
    {
        if((Is_ops(e[i-1])==Is_ops==e[i]==1)||(Is_ops(e[i-1])==0&&Is_ops(e[i])==2))
        {
            printf("%c %c\n",e[i-1],e[i]);
            printf("输入表达式有误\n");
            exit(0);
        }
        i++;
    }
}


double getNum(double b,double a,char c)
{
    switch(c)
    {
        case '+':return a+b;break;
        case '-':return a-b;break;
        case '*':return a*b;break;
        case '/':return a/b;break;
    }
    return 1;
}

void count(Stack_s* s,Stack_n* n)
{
    int a,b,nums;
    char c;
    a=gettop_ovs(n),pop_ovs(n);
    b=gettop_ovs(n),pop_ovs(n);
    c=gettop_ops(s),pop_ops(s);
    nums=getNum(a,b,c);
    push_ovs(n,nums);
}


double val(Stack_s*  s,Stack_n* n,char e[MAX])
{
    int i=0,j=0;
    double a,b,transformNUM,nums;
    char c;
    char buff[MAX]={'0'};
    judge(e);
    while(e[i])
    {
        if(e[i]>='0'&&e[i]<='9')
        {
            while((e[i]>='0'&&e[i]<='9')||e[i]=='.')      //多位数进行处理
            {
                buff[j++]=e[i++];
            }
            transformNUM=(double)atof(buff);
            push_ovs(n,transformNUM);
            for(int i=0;i<j;i++)
            {
                buff[i]='\0';
            }
            j=0;
        }
        else if(e[i]=='+'||e[i]=='-')
        {
            if(s->top==-1)
            {
                push_ops(s,e[i++]);
            }
            else if(Judge_ops(gettop_ops(s),e[i])&&n->top>=1)
            {
                count(s,n);
            }
            else if(gettop_ops(s)!='(')
            {
                a=pop_ovs(n);
                c=pop_ops(s);
                nums=getNum(a,0,c);
                push_ovs(n,nums);
                push_ops(s,e[i++]);
            }
            else push_ops(s,e[i++]);
        }
        else if(e[i]=='*'||e[i]=='/')
        {
            if(s->top==-1)
            {
                push_ops(s,e[i]);
            }
            else
            {
                if(Judge_ops(gettop_ops(s),e[i])&&n->top>=1)
                {
                    count(s,n);
                }
                push_ops(s,e[i++]);
            }
        }
        else if(e[i]=='(')
        {
            push_ops(s,e[i++]);
        }
        else if(e[i++]==')')
        {
            while(gettop_ops(s)!='(')
            {
                count(s,n);
            }
            pop_ops(s);
        }
    }
    while(s->top!=-1)
    {
        if(s->top==0&&n->top==0)
        {
            a=gettop_ovs(n),pop_ovs(n);
            c=gettop_ops(s),pop_ops(s);
            nums=getNum(a,0,c);
            push_ovs(n,nums);
        }
        else
        {
            count(s,n);
        }
    }
    return gettop_ovs(n);
}

int main()
{
    Stack_s* s=InitStack_s();
    Stack_n* n=InitStack_n();
    printf("请输入一个算术表达式\n");
    char e[MAX];
    scanf("%s",e);
    printf("%lf\n",val(s,n,e));
    return 0;
}

还有优化的空间，大佬可下方留言