简单计算器

/************
按照四则运算加、减、乘、除、幂（^）和括号的优先关系和惯例，编写计算器程序。要求：
A、从键盘输入一个完整的表达式，以回车作为表达式输入结束的标志。
B、输入表达式中的数值均为大于等于零的整数。中间的计算过程如果出现小数也只取整。
例如，输入：4+2*5= 输出：14
输入：(4+2)*(2-10)= 输出：-48
***************/
#include
#include
#include

#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
//#define OVERFLOW -2
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0

typedef int Status;

char OP[]= {'+','-','*','/','(',')','^','%','='}; //定义运算符数组

typedef struct
{
char *base;
char *top;
int stacksize;
} SqStack1; //定义运算符栈数据类型

typedef struct
{
int *base;
int *top;
int stacksize;
} SqStack2; //定义操作数栈数据类型

SqStack1 OPTR; //声明运算符栈
SqStack2 OPND; //声明操作数栈

Status InitStack1(SqStack1 &S)
{
//构造运算符栈
S.base=(char *)malloc(STACK_INIT_SIZE*sizeof(char));//申请空间
if(!S.base)exit(OVERFLOW); //存储分配失败
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}

Status InitStack2(SqStack2 &S)
{
//构造操作数栈
S.base=(int *)malloc(STACK_INIT_SIZE*sizeof(int));//申请空间
if(!S.base)exit(OVERFLOW); //存储分配失败
S.top=S.base;
S.stacksize=STACK_INIT_SIZE;
return OK;
}

char GetTop1(SqStack1 S)
{
//取得运算符栈的栈顶元素
char e;
if(S.top==S.base) return ERROR; //栈空
e=*(S.top-1);
return e;
}

int GetTop2(SqStack2 S)
{
//取得操作数栈的栈顶元素
int e;
if(S.top==S.base) return ERROR; //栈空
e=*(S.top-1);
return e;
}

Status Push1(SqStack1 &S,char e)
{
//插入元素e为运算符栈的栈顶元素
if(S.top-S.base>=S.stacksize)
{
//栈满，追加存储空间
S.base=(char*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(char));
if(!S.base) exit(OVERFLOW);//存储分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}

Status Push2(SqStack2 &S,int e)
{
//插入元素e为操作数栈的栈顶元素
if(S.top-S.base>=S.stacksize)
{
//栈满，追加存储空间
S.base=(int*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(int));
if(!S.base) exit(OVERFLOW); //存储分配失败
S.top=S.base+S.stacksize;
S.stacksize+=STACKINCREMENT;
}
*S.top++=e;
return OK;
}

Status Pop1(SqStack1 &S,char &e)
{
//删除表达式栈的栈顶元素并用e返回
if(S.top==S.base) return ERROR; //栈空
e=*--S.top;
return OK;
}

Status Pop2(SqStack2 &S,i

nt &e)
{
//删除表达式栈的栈顶元素并用e返回
if(S.top==S.base) return ERROR; //栈空
e=*--S.top;
return OK;
}

Status In(int m,char a[])
{
//判断m若是运算符，返回TRUE，否则返回FALSE
for(int n=0; a[n]!='\0'; n++)
if(m==a[n]) return TRUE;
return FALSE;
}

char Precede(char m,char n)
{
//判断m与n的优先级
switch(m)
{
case'+':
case'-':
if(n=='+'||n=='-'||n==')'||n=='=')
return '>';
else return '<';
break;
case'*':
case'/':
case'^':
case'%':
if(n=='(')
return '<';
else return '>';
break;
case'(':
if(n==')')
return '=';
else if(n=='=')
return ERROR;
else return '<';
break;
case')':
if(n=='(')
return ERROR;
else return '>';
break;
case'=':
if(n=='=')
return '=';
else if(n==')')
return ERROR;
else return '<';
break;
default:
return ERROR;
break;//其他情况，表达式有误
}
}

int Operation(int a,char theta,int b)
{
//运算函数
switch(theta)
{
case'+':
return a+b;
break;
case'-':
return a-b;
break;
case'*':
return a*b;
break;
case'/':
return a/b;
break;
case'%':
return a%b;
break;
case'^':
return pow(a,b);
break;
default:
return ERROR;
break;
}
}

int EvaluateExpression(char p[])
{
//主要操作函数
int a,b,t;
char x,theta,temp[10];
char* num=temp;
char* ex=p;//声明指针
InitStack1(OPTR);
Push1(OPTR,'=');
InitStack2(OPND);
char c=*p;
while(c!='='||GetTop1(OPTR)!='=')
{
if(!In(c,OP))
{
//不是运算符进数组
*(num++)=c;
c=*(++ex);
if(In(c,OP))
{
//是运算符将数组压入栈
*num='\0';
t=atoi(temp); //将temp数组转化为整型数
num=temp;//指针指回数组头元素
Push2(OPND,t);
}
}
else
switch(Precede(GetTop1(OPTR),c))
{
case '<'://栈顶元素优先级低
Push1(OPTR,c);
c=*(++ex);
break;
case '='://脱括号并接受下一字符
Pop1(OPTR,x);
c=*(++ex);
break;
case '>'://运算并将结果入栈
Pop1(OPTR,theta);
Pop2(OPND,b);
Pop2(OPND,a);
Push2(OPND,Operation(a,theta,b));
break;
}
}
return GetTop2(OPND);//

返回操作数栈顶元素
}

int main()
{
//主函数
int result;
char expression[100]; //声明表达式数组

printf("****************************************\n");
printf("可以计算加减乘除幂模，输入以\"=\"结尾。\n");
printf("示例：\n");
printf("请输入表达式：(4+2)*(2-10)=\n");
printf("计算结果是：-48\n");
printf("****************************************\n");

printf("请输入表达式:");
gets(expression); //输入数组
result=EvaluateExpression(expression);
printf("计算结果是:%d\n",result);//输出结果
system("pause");
return 0;
}