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;
}

C语言 计算器

猜你喜欢