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;

扫描二维码关注公众号,回复: 2540907 查看本文章

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

猜你喜欢

转载自blog.csdn.net/chen1042246612/article/details/81385255