## C语言 计算器

//只实现了整数的四则运算

#include<stdio.h>
#include<malloc.h>
#include<process.h>

//using namespace std;

#define STACK_INIT_SIZE 100           //定义常量
#define STACKINCREMENT 10

typedef char SElemType;           //更名

typedef struct{             //定义结构体，并更名
SElemType *base;           //头部地址

SElemType *top;           //尾部地址

int stacksize;            //大小
}SqStack;

int InitStack(SqStack &S){          //定义栈
S.base = (SElemType *)malloc(STACK_INIT_SIZE * sizeof(SElemType));    //分配空间

if(!S.base){               //若栈不存在，则结束
exit(-1);
}

S.top = S.base;

S.stacksize = STACK_INIT_SIZE;

return 1;
}

char GetTop(SqStack S){            //获得栈中数据
if(S.top == S.base){           //若栈为空，返回-1
return -1;
}

char e;

e = *(S.top - 1);            //获取栈顶数据

return e;
}

int Push(SqStack &S, SElemType e){         //向栈中压入新数据
if(S.top - S.base >= S.stacksize){        //若空间不够，需要扩充空间
S.base = (SElemType*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(SElemType));  //扩充空间

if(!S.base)              //若栈不存在，结束

exit(-1);

S.top = S.base + S.stacksize;

S.stacksize += STACKINCREMENT;
}

*S.top++ = e;          //向栈中添加数据

return  1;
}

int Pop(SqStack &S, SElemType &e){      //取出栈顶数据，
if(S.top == S.base){
return -1;
}

e = * --S.top;

return 1;
}

typedef struct{          //定义结构体(整型)
int  *base;

int *top;

int stacksize;
}sqStack;

int initStack(sqStack &S){
S.base = (int *)malloc(STACK_INIT_SIZE * sizeof(int));

if(!S.base){
exit(-1);
}

S.top = S.base;

S.stacksize = STACK_INIT_SIZE;

return 1;
}

int getTop(sqStack S){
if(S.top == S.base){
return -1;
}

int e;

e = *(S.top - 1);

return e;
}

int push(sqStack &S, int e){
if(S.top - S.base >= S.stacksize){
S.base = (int*)realloc(S.base, (S.stacksize + STACKINCREMENT) * sizeof(int));

if(!S.base)

exit(-1);

S.top = S.base + S.stacksize;

S.stacksize += STACKINCREMENT;
}

*S.top++ = e;

return  1;
}

int pop(sqStack &S, int &e){
if(S.top == S.base){
return -1;
}

e = * --S.top;

return 1;
}

int In(char c){       //判断字符

switch(c){
case '+' :

case '-' :

case '*' :

case '/' :

case '(' :

case ')' :

case '#' :

return 1;

break;

default:

return 0;
}
}

char precede(char c, char s){      //判断优先级
if(c == '+'){
if(s == '+' || s == '-' || s == ')' || s == '#'){
return '>';
}
else{
return '<';
}
}

else
if(c == '-'){

if(s == '+' || s == '-' || s == ')' || s == '#'){
return '>';
}
else{
return '<';
}

}

else
if(c == '*'){
if(s == '('){
return '<';
}

else{
return '>';
}
}

else
if(c == '/'){

if(s == '('){
return '<';
}

else{
return '>';
}
}

else
if(c == '('){
if(s == ')'){
return '=';
}

else{
return '<';
}
}

else
if(c == ')'){

if(s == '('){
return 'e';
}

else
{
return '>';
}
}

else
{
if(s == ')'){
return 'e';
}

else
if(s == '#'){
return '=';
}
else
{
return '<';
}
}
}

int Operate(int c, char c1, int c2){     //两个数字进行计算
int a = c ;

int b = c2 ;

switch(c1){
case '+':
return a + b ;

break;

case '-':

return a - b ;

break;

case '*':

return a * b ;

break;

case '/':

return a / b ;

break;
}
}

int shy(){
SqStack OPTR;       //定义栈空间(字符型)

sqStack OPND;       //定义栈空间(整型)

InitStack(OPTR);      //分配空间

Push(OPTR, '#');

initStack(OPND);      //分配空间

char c = getchar();      //开始输入数据

char x;

char theta;

int a;

int b;

char e;

int t = 0;

int data;

while(c != '#' || GetTop(OPTR) != '#'){
if(In(c) != 1){         //判断数据是数字字符还是符号字符
//若为数字字符
if(t == 1){         //t为判断数字字符是否连续的标志
pop(OPND,data);

push(OPND, data * 10 + c - '0');  //将数字字符转换成整型，压入int型栈中

c = getchar();       //继续输入数据
}
else{
push(OPND, c - '0');

t = 1;

c = getchar();
}
}

else{           //如果是符号字符
t = 0;

switch(precede(GetTop(OPTR), c)){   //比较新输入的字符与栈顶字符的优先级
case '<':
Push(OPTR, c);

c = getchar();

break;

case '=':
Pop(OPTR, x);

c = getchar();

break;

case '>':        //若栈中的优先级高

Pop(OPTR, theta);        //取出栈顶符号字符

pop(OPND, b);      //取出int型栈中的两个数据

pop(OPND, a);

push(OPND, Operate(a, theta, b)); //进行计算，并将计算结果压入int型栈中

break;
}
}
}

return getTop(OPND);
}

int main(){

int c = shy();

printf("%d", c);

return 0;
}