21ic电子技术开发论坛»论坛首页 › 单片机与嵌入式系统 › 小华半导体 › 四则运算计算器算法
返回列表 发新帖我要提问

[方案相关] 四则运算计算器算法

[复制链接]
 楼主| 发表于 2025-6-23 13:59 | 显示全部楼层 |阅读模式
计算器, ar, HA, ST, ID
复制
  1.   /**************************************************************************************
    

  2.                 *                              四则运算计算器                                                                                                  *
    

  3.                 *          键盘使用：s1-s16分别为：0,1,2,3,4,5,6,7,8,9,+,-,*,/,(,),共16个键
    

  4.                 *                k1-k3  分别为：= ~ . 
    

  5.                 *     连接方法：P24连K1, J20连JP3, 插上LCD1602
    

  6.                 *     三步走策略，如下：
    

  7.                 *          1.输入，解决按键响应问题。2022.1.1解决！
    

  8.                 *     2.输出，解决显示问题。        2022.1.2解决！2022.1.3完善！
    

  9.                 *     3.运算，解决四则运算问题。
    

  10.                             (1)解决状态机问题。     2022.1.4解决！
    

  11.                                 (2)确定状态机能工作                2022.1.5解决！
    

  12.                                 (3)解决运算问题。                2022.1.6初成！
    

  13.                 *     4.排查，检测边界情况。        2022.1.6大致解决，仍有瑕疵!                                                                      
    

  14.                 *                                                                                                                                                                          *
    

  15.                 ***************************************************************************************/
    

  16.                 
    

  17.                 #include <reg51.h>           //此文件中定义了51的一些特殊功能寄存器
    

  18.                 #include "stdio.h"
    

  19.                 #include "stdlib.h"           //此文件中有内存池初始化函数
    

  20.                 #include <math.h>
    

  21.                 #define uchar unsigned char
    

  22.                 #define uint unsigned int
    

  23.                 #define  MAX_LEN 10
    

  24.                 sbit EN=P2^7;  //LCD的使能引脚
    

  25.                 sbit RS=P2^6;  //LCD数据命令选择端
    

  26.                 sbit RW=P2^5;  //LCD的读写选择端
    

  27.                 
    

  28.                 //19个键盘
    

  29.                 sbit K1=P2^4;   //= 键
    

  30.                 sbit K2=P2^3;   //~ 键
    

  31.                 sbit K3=P2^2;   //. 键
    

  32.                 uchar KEY_CODE[]={ 0xee,0xde,0xbe,0x7e,//4X4矩阵键盘键值表，0-9, + - * / ( ), 共16个
    

  33.                                                    0xed,0xdd,0xbd,0x7d,
    

  34.                            0xeb,0xdb,0xbb,0x7b,
    

  35.                            0xe7,0xd7,0xb7,0x77};
    

  36.                 //定义字符键值表
    

  37.                 uchar CHAR_TABLE[]={0x30,0x31,0x32,0x33,//这四个会在液晶显示器中显示0 1 2 3
    

  38.                                     0x34,0x35,0x36,0x37,//这四个会显示4 5 6 7 
    

  39.                                                         0x38,0x39,0x2b,0x2d,//这个四个会显示8 9 + -
    

  40.                                                         0x2a,0x2f,0x28,0x29,//这个四个会显示* / ( )
    

  41.                                                         0x3d,0x7e,0x2e};        //这三个会显示= ~ . 共19个
    

  42.                 //运算优先级表,不使用，太占内存
    

  43.                 /*uchar PRIORITY[]={'>','>','<','<','<','>',//先行后列，顺序为+ - * / ( )
    

  44.                                                   '>','>','<','<','<','>',
    

  45.                                                   '>','>','>','>','<','>',
    

  46.                                                   '>','>','>','>','<','>',
    

  47.                                                   '<','<','<','<','<','=',
    

  48.                                                   '>','>','>','>',' ','>'};*/
    

  49.         
    

  50.                 void scanf_(uchar *var);//从矩阵键盘中获取值
    

  51.                 void print(uchar outStr);//打印字符串
    

  52.                 void delay5MS();
    

  53.                 void delay100MS();
    


  54. 

  55.                 void writeCMD(uchar com);//写命令子程序
    

  56.                 void showOneChar(uchar dat);//写数据子程序
    

  57.                 void init();//初始化子程序，初始化液晶显示屏
    

  58.                 void clear();//清除显示屏上的显示
    


  59. 

  60.                 //核心处理函数
    

  61.                 uchar stateChange(uchar inp);
    

  62.                 //比较优先级函数
    

  63.                 uchar cp_priority(uchar cur);
    

  64.                 //计算函数
    

  65.                 void calculate(uchar inp);
    

  66.                 //检查除法异常函数
    

  67.                 uchar jd_abnormal();
    

  68.                 //状态刷新函数,核心处理函数开头
    

  69.                 void rf_state();
    

  70.                 //获取状态类别
    

  71.                 uchar getClass(uchar var);
    

  72.                 //压栈函数
    

  73.                 void push_st(uchar inp);
    

  74.                 //更新tmp值
    

  75.                 void getTmp(uchar inp);
    

  76.                 //最终运算
    

  77.                 void last_cal(double op2, double op1, uchar opr);
    

  78.                 //显示最终结果
    

  79.                 void showAns();
    


  80. 


  81. 

  82.                 //建立堆栈                 
    

  83.                  uchar str[10];//符号堆栈
    

  84.                  double std[5];//数堆栈
    

  85.                  //栈顶位置
    

  86.                  int topd = -1;
    

  87.                  int topr = -1;
    

  88.                  //暂存数据
    

  89.                  double tmp = 0;
    

  90.                  //状态标志位
    

  91.                  uchar state = 0;//共8个状态，具体所指请看文档
    

  92.                  uchar current = 0;//指示当前状态，tmp处理使用
    

  93.                  uchar bracket = 0;//括号状态，0无或有右括号，1有左括号
    

  94.                  uchar negative = 0;//负号状态，0无符号，1有负号
    

  95.                  uchar point = 0;//点状态，0无点，1有点
    

  96.                  uchar pl = 0;//点位置，0初始位，值为当前是点后第几位
    

  97.                  uchar sfs = 0;//可能的除0异常状态，0表示当前可能异常，1代表没异常
    

  98.                 
    

  99.                 
    

  100.         void main()
    

  101.                 {
    


  102. 

  103.                  //准备工作，其中num为获取的键盘字符。
    

  104.                  uchar num=0xff;
    

  105.                  //app
    

  106.                  int ts = 0;
    

  107.                  init();
    

  108.                  //初始化堆栈
    

  109.                  //init_mempool(&str, sizeof(str));
    

  110.                  //init_mempool(&std, sizeof(std));
    


  111. 

  112.                  while(1)
    

  113.                  {                     
    

  114.                          scanf_(&num);
    

  115.                         current = getClass(num);//(1)获取当前输入的状态
    

  116.                         if(stateChange(num))//当输入有效
    

  117.                         {
    

  118.                                 //app处理满屏问题
    

  119.                                 if(ts == 10)
    

  120.                                 {
    

  121.                                         init();
    

  122.                                         ts = 0;
    

  123.                                 }
    

  124.                                 push_st(num);
    

  125.                                 if(num != '=')//等号特殊，必须先输出
    

  126.                                         print(num);                        
    

  127.                                 state = current;//(1)更新state状态
    

  128.                                 
    

  129.                                 //app
    

  130.                                 ++ts;        
    

  131.                         }        
    

  132.                  }
    

  133.                 }
    

  134.      /**********从键盘获取值得函数类似于C语言的scanf()函数**************/                                
    

  135.         void scanf_(uchar *var)
    

  136.                 {
    

  137.                    uchar temp,num;
    

  138.                    int i=1;
    

  139.                    temp=i;
    


  140. 

  141.                    
    

  142.                    
    

  143.                         while(1){
    


  144. 

  145.              if(!K1)
    

  146.                          {
    

  147.                                  delay100MS(); //延时，软件消除抖动。
    

  148.                              if(!K1)
    

  149.                                  {
    

  150.                                          while(!K1);
    

  151.                                     *var = '=';
    

  152.                                         break;
    

  153.                                  }
    

  154.                          }
    

  155.                          else if(!K2)
    

  156.                          {
    

  157.                                  delay100MS(); //延时，软件消除抖动。
    

  158.                              if(!K2)
    

  159.                                  {
    

  160.                                          while(!K2);
    

  161.                                     *var = '~';
    

  162.                                         break;
    

  163.                                  }
    

  164.                          }
    

  165.                          else if(!K3)
    

  166.                          {
    

  167.                                  delay100MS(); //延时，软件消除抖动。
    

  168.                              if(!K3)
    

  169.                                  {
    

  170.                                          while(!K3);
    

  171.                                     *var = '.';
    

  172.                                         break;
    

  173.                                  }
    

  174.                          }
    


  175. 

  176.                      P1 = 0x0f;//置行为高电平，列为低电平。这样用于检测行值。
    

  177.                          if(P1!=0x0f)
    

  178.                          {
    

  179.                              delay100MS(); //延时，软件消除抖动。
    

  180.                                  temp=P1; //保存行值
    

  181.                                  P1=0xf0; //置行为低电平，列为高电平，获取列
    

  182.                                    if(P1!=0xf0)
    

  183.                                 {
    

  184.                                   num=temp|P1; //获取了按键位置
    

  185.                                   //P2=1;
    

  186.                                   for(i=0;i<16;i++)
    

  187.                                    if(num==KEY_CODE[i])
    

  188.                                         {
    

  189.                                            
    

  190.                                            if(i==10)*var='+';//获取加号的值
    

  191.                                        else if(i==11)*var='-';//获取减号的值
    

  192.                                            else if(i==12)*var='*';//获取乘号的值
    

  193.                                            else if(i==13)*var='/';//获取除号的值
    

  194.                                            else if(i==14)*var='(';//获取左括号号的值
    

  195.                                            else if(i==15)*var=')';//获取右括号的值
    

  196.                                    else *var=i;//获取数值
    

  197.                                      
    

  198.                                     }
    

  199.                                    break;        //跳出循环，为了只获取一个值
    

  200.                                  }
    

  201.                          }         
    

  202.                         }
    


  203. 

  204.                   }
    


  205. 

  206.         /******************显示函数***************************/
    

  207.     void print(uchar arr)
    

  208.         {         
    

  209.     uint t=0,j=0;
    

  210.         uint location;
    

  211.          if(arr == '=') location = 16;
    

  212.          else if(arr == '~')location = 17;
    

  213.          else if(arr == '.')location = 18;
    

  214.          else if(arr == '+')location = 10;
    

  215.          else if(arr == '-')location = 11;
    

  216.          else if(arr == '*')location = 12;
    

  217.          else if(arr == '/')location = 13;
    

  218.          else if(arr == '(')location = 14;
    

  219.          else if(arr == ')')location = 15;
    

  220.          else{
    

  221.                 for(j=0;j<10;j++)
    

  222.                 if(arr == j)location = j;
    

  223.                  }
    


  224. 

  225.          showOneChar(CHAR_TABLE[location]);        
    

  226.           
    

  227.         }
    

  228.                 
    

  229.     /*********************短延时函数*************************/
    

  230.                   void delay5MS()
    

  231.                   {
    

  232.                     int n=3000;
    

  233.                         while(n--);
    

  234.                   }
    


  235. 

  236.    /*****************定义长点的延时程序**********************/
    

  237.          void delay100MS()
    

  238.           {
    

  239.             uint n=10000;
    

  240.                 while(n--);
    

  241.           }
    

  242.    /*******************写命令子程序**************************/
    

  243.            void writeCMD(uchar com)
    

  244.         {
    

  245.             P0=com;          //com为输入的命令码。通过P2送给LCD
    

  246.             RS=0;      //RS=0选择指令寄存器
    

  247.             RW=0;           //RW=0为写
    

  248.                 delay5MS();          
    

  249.                 EN=1;      //LCD的使能端E置高电平，读取信息
    

  250.                 delay5MS();
    

  251.                 EN=0;       //LCD的使能端E置低电平，执行指令
    

  252.           
    

  253.         }
    

  254.   /*******************写数据子程序**************************/
    

  255.         void showOneChar(uchar dat)
    

  256.         {
    

  257.                 P0=dat;           //写入数据
    

  258.                 RS=1;      //RS=1选择数据寄存器
    

  259.                 RW=0;           //RW=0为写
    

  260.                 EN=1;           //读取信息
    

  261.                 delay5MS();
    

  262.                 EN=0;           //执行指令
    

  263.           
    

  264.          }
    

  265.  /*******************初始化函数**************************/
    

  266.          void init()
    

  267.          {
    

  268.                 EN=0;       
    

  269.                 writeCMD(0x38);//设置显示模式
    

  270.              writeCMD(0x0e);//光标打开，不闪烁
    

  271.                 writeCMD(0x06);//写入一个字符后指针地址+1，写一个字符时整屏不移动
    

  272.                 writeCMD(0x01);//清屏显示，数据指针清0，所以显示清0
    

  273.                 writeCMD(0x80);//设置字符显示的首地址，指明了数据块的首地址为P0
    

  274.          }
    


  275. 

  276.  /*********************清屏子程序**********************/
    

  277.   void clear()
    

  278.   {
    

  279.     EN=0;
    

  280.         writeCMD(0x01);
    

  281.     
    

  282.   }
    


  283. 


  284. 

  285.   /*********************核心处理函数**********************/
    

  286.   uchar stateChange(uchar inp)
    

  287.   {
    

  288.   //刷新所有状态
    

  289.   rf_state();
    

  290.   //状态机分类处理
    

  291.   if(inp>=0&&inp<=9)//1类输入*********
    

  292.   {
    

  293.     
    

  294.           if(4 != state && 7 != state)//有效，但要考虑可能的异常情况
    

  295.         {
    

  296.                 //考虑除数异常状况
    

  297.                 if(inp == 0&&state==2&&str[topr]=='/')
    

  298.                         sfs = 1;
    

  299.                 else
    

  300.                         sfs = 0;
    

  301.                 //考虑点可能存在
    

  302.                 if(1 == point)
    

  303.                         pl++;
    

  304.                 //处理tmp入栈,注意负号，点存在，点位置-------------交给push函数了-------------------                
    

  305.         return 1;
    

  306.         }
    

  307.   }
    

  308.   else if(inp=='+'||inp=='-'||inp=='*'||inp=='/')//2类输入*********
    

  309.   {
    

  310.           if((state==1||state==4||state==7)&&!jd_abnormal())//有效，
    

  311.         {
    

  312.                 if(topr != -1)//当符号栈不空，才进入比较与计算
    

  313.                 calculate(inp);
    

  314.         return 1;
    

  315.         }
    

  316.   }
    

  317.   else if(inp=='(')//3类输入*********
    

  318.   {
    

  319.           if((state==0||state==2)&&bracket==0)//有效
    

  320.         {
    

  321.         bracket = 1;
    

  322.         return 1;
    

  323.         }
    

  324.   }
    

  325.   else if(inp==')')//4类输入*********
    

  326.   {
    

  327.           if(state==1&&bracket==1&&!jd_abnormal())//有效
    

  328.         {
    

  329.         //test,(数)没考虑
    

  330.         calculate(inp);
    

  331.         bracket = 0;
    

  332.         return 1;
    

  333.         }
    

  334.   }
    

  335.   else if(inp=='~')//5类输入*********
    

  336.   {
    

  337.           if(state==0||state==2||state==3)//有效
    

  338.         {
    

  339.         negative = 1;
    

  340.         return 1;
    

  341.         } 
    

  342.   }
    

  343.   else if(inp=='.')//6类输入*********
    

  344.   {
    

  345.           if(state==1&&point==0)//有效
    

  346.         {
    

  347.         point = 1;
    

  348.         return 1;
    

  349.         }
    

  350.   
    

  351.   }
    

  352.   else if(inp=='=')//7类输入*********
    

  353.   {
    

  354.           if(bracket==0&&(state==1||state==4)&&!jd_abnormal())//有效
    

  355.         {
    

  356.         print(inp);//等号特殊，先显示等号
    

  357.         calculate(inp);//再进行计算
    

  358.         return 1;
    

  359.         }
    

  360.   }
    


  361. 

  362.   return 0;//0为无效，1为有效
    

  363.   }
    


  364. 

  365.   /********************比较优先级函数**********************/
    

  366.   uchar cp_priority(uchar cur)//竖着输入,cur为当前有效输入
    

  367.   {
    

  368.   uchar res='=';
    

  369.   if(cur=='+')//输入是加号
    

  370.   {
    

  371.           if(str[topr]=='+')
    

  372.                 res = '>';
    

  373.         else if(str[topr]=='-')
    

  374.                 res = '>';
    

  375.         else if(str[topr]=='*')
    

  376.                 res = '>';
    

  377.         else if(str[topr]=='/')
    

  378.                 res = '>';
    

  379.         else if(str[topr]=='(')
    

  380.                 res = '<';
    

  381.         else if(str[topr]==')')
    

  382.                 res = '>';
    

  383.   }
    

  384.   else if(cur=='-')//输入是减号
    

  385.   {
    

  386.           if(str[topr]=='+')
    

  387.                 res = '>';
    

  388.         else if(str[topr]=='-')
    

  389.                 res = '>';
    

  390.         else if(str[topr]=='*')
    

  391.                 res = '>';
    

  392.         else if(str[topr]=='/')
    

  393.                 res = '>';
    

  394.         else if(str[topr]=='(')
    

  395.                 res = '<';
    

  396.         else if(str[topr]==')')
    

  397.                 res = '>';
    

  398.   }
    

  399.   else if(cur=='*')//输入是乘号
    

  400.   {
    

  401.           if(str[topr]=='+')
    

  402.                 res = '<';
    

  403.         else if(str[topr]=='-')
    

  404.                 res = '<';
    

  405.         else if(str[topr]=='*')
    

  406.                 res = '>';
    

  407.         else if(str[topr]=='/')
    

  408.                 res = '>';
    

  409.         else if(str[topr]=='(')
    

  410.                 res = '<';
    

  411.         else if(str[topr]==')')
    

  412.                 res = '>';
    

  413.   }
    

  414.   else if(cur=='/')//输入是除号
    

  415.   {
    

  416.           if(str[topr]=='+')
    

  417.                 res = '<';
    

  418.         else if(str[topr]=='-')
    

  419.                 res = '<';
    

  420.         else if(str[topr]=='*')
    

  421.                 res = '>';
    

  422.         else if(str[topr]=='/')
    

  423.                 res = '>';
    

  424.         else if(str[topr]=='(')
    

  425.                 res = '<';
    

  426.         else if(str[topr]==')')
    

  427.                 res = '>';
    

  428.   }
    

  429.   else if(cur=='(')//输入是左括号
    

  430.   {
    

  431.           if(str[topr]=='+')
    

  432.                 res = '<';
    

  433.         else if(str[topr]=='-')
    

  434.                 res = '<';
    

  435.         else if(str[topr]=='*')
    

  436.                 res = '<';
    

  437.         else if(str[topr]=='/')
    

  438.                 res = '<';
    

  439.         else if(str[topr]=='(')
    

  440.                 res = '<';
    

  441.         else if(str[topr]==')')
    

  442.                 res = ' ';
    

  443.   }
    

  444.   else if(cur==')')//输入是右括号
    

  445.   {
    

  446.           if(str[topr]=='+')
    

  447.                 res = '>';
    

  448.         else if(str[topr]=='-')
    

  449.                 res = '>';
    

  450.         else if(str[topr]=='*')
    

  451.                 res = '>';
    

  452.         else if(str[topr]=='/')
    

  453.                 res = '>';
    

  454.         else if(str[topr]=='(')
    

  455.                 res = '=';
    

  456.         else if(str[topr]==')')
    

  457.                 res = '>';
    

  458.   }
    

  459.   else if(cur=='=')//遗漏情况
    

  460.           res = '>';
    


  461. 

  462.   return res;//res为比较符号
    

  463.   }
    

  464.   /*********************计算函数**********************/                
    

  465.   void calculate(uchar inp)
    

  466.   {
    

  467.   //操作数和操作号
    

  468.   double op1 = 0;
    

  469.   double op2 = 0;
    

  470.   uchar opr = '=';
    


  471. 

  472.   uchar cp = '=';
    

  473.           cp = cp_priority(inp);
    

  474.           if(cp == '>')//执行运算-------注意=情况没讨论------------------------------
    

  475.           {
    

  476.                 if(inp == ')')//右括号情况特殊，
    

  477.                 {
    

  478.                         //对于括号内部,可能需要连环操作，如(1+2*3)=
    

  479.                         while(str[topr]!='(')
    

  480.                         {
    

  481.                                 opr = str[topr--];//运算号出栈
    


  482. 

  483.                                 op1 = std[topd--];//运算数1出栈
    

  484.                                 op2 = std[topd--];//运算数2出栈
    


  485. 

  486.                                 last_cal(op2, op1, opr);
    

  487.                         }
    

  488.                         //对于括号外部,左括号的到来容易造成堆积---如1+2*(7),留给最后等号处理--------------------
    

  489.                         topr--;
    

  490.                         //test
    

  491.                         //print(str[topr]);
    

  492.                 }                
    

  493.                 else
    

  494.                 {
    

  495.                         opr = str[topr--];//运算号出栈
    


  496. 

  497.                         op1 = std[topd--];//运算数1出栈
    

  498.                         op2 = std[topd--];//运算数2出栈
    


  499. 

  500.                         last_cal(op2, op1, opr);
    

  501.                 }
    

  502.                                 
    

  503.                 //test,error,can't go here------------因为在if中------------------------                        
    

  504.           }
    


  505. 

  506.         if(cp == '=')//左括号和右括号临近时
    

  507.                 topr--;
    


  508. 

  509.         if(inp == '=')//最终结果可能需要多次运算,直到栈内剩下一个数
    

  510.         {
    

  511.                 //test
    

  512.                 /*print('*');
    

  513.                 tmp=op2;
    

  514.                 showAns();
    

  515.                 print(opr);
    

  516.                 tmp=op1;
    

  517.                 showAns();
    

  518.                 print('*');*/
    


  519. 

  520.                 while(topd!=0)//没到底，就算到底----------------------------------
    

  521.                 {
    

  522.                         opr = str[topr--];//运算号出栈
    


  523. 

  524.                         op1 = std[topd--];//运算数1出栈
    

  525.                         op2 = std[topd--];//运算数2出栈
    


  526. 

  527.                         last_cal(op2, op1, opr);
    

  528.                 }
    

  529.                 tmp = std[topd]; //到底了，输出结果
    

  530.                 showAns();
    

  531.                 
    

  532.         }
    


  533. 

  534.   }
    

  535.   /*********************检查除法异常函数**********************/
    

  536.   uchar jd_abnormal()
    

  537.   {
    

  538.           if(sfs==1)
    

  539.           {        
    

  540.           //数出栈--------------------------------------------------------
    

  541.         topd--;
    

  542.         //回复到前前状态
    

  543.         sfs = 0;
    

  544.         state = 2;
    

  545.         //输入无效
    

  546.         return 1;
    

  547.           }
    

  548.   return 0;//0为正常，1为异常   
    

  549.   }
    


  550. 

  551.   /*********************状态刷新函数**********************/
    

  552.   void rf_state()
    

  553.   {
    

  554.           if(state!=1&&state!=5&&state!=6)//当上一个输入和数无关，重置和数相关的所有状态位和暂存数
    

  555.           {
    

  556.         negative = 0;
    

  557.         point = 0;
    

  558.         pl = 0;
    

  559.         tmp = 0;//不知为何出错-----------旧版本编译器缺少处理浮点数的c51fs.lib文件----------------------------------------------------
    

  560.           } 
    

  561.   } 
    


  562. 

  563.   /*********************获取状态类别函数*********************/
    

  564.   uchar getClass(uchar inp)
    

  565.   {
    

  566.   if(inp>=0&&inp<=9)
    

  567.           return 1;
    


  568. 

  569.   else if(inp=='+'||inp=='-'||inp=='*'||inp=='/')
    

  570.           return 2;
    


  571. 

  572.   else if(inp=='(')
    

  573.           return 3;
    


  574. 

  575.   else if(inp==')')
    

  576.           return 4;
    


  577. 

  578.   else if(inp=='~')
    

  579.           return 5;
    


  580. 

  581.   else if(inp=='.')
    

  582.           return 6;
    


  583. 

  584.   else if(inp=='=')
    

  585.           return 7;
    


  586. 

  587.   return 0;
    

  588.   }
    

  589.   /*********************压栈函数*********************/
    

  590.   void push_st(uchar inp)
    

  591.   {
    

  592.           if(current==1)//压数,注意考虑和数相关的negative,point,pl,tmp----------------------------------
    

  593.         {
    

  594.                 getTmp(inp);//有效输入到当前为止的数是tmp
    

  595.                 if(state!=1&&state!=6)//当上一次输入的不是数字，说明上一次没存数,入栈
    

  596.                 {
    

  597.                         topd++;
    

  598.                         std[topd] = tmp;
    

  599.                 }
    

  600.                 else //当上一次输入的是数字，则覆盖上次的数
    

  601.                         std[topd] = tmp;
    

  602.         }
    

  603.         else if(current==2||current==3||current==4)//压符号[=-*/][(][)]
    

  604.         {
    

  605.                 if(inp != ')')//右括号需要特殊处理
    

  606.                 {
    

  607.                         topr++;
    

  608.                         str[topr] = inp;
    

  609.                 }
    


  610. 

  611.                 /*if(str[topr] ==')'&&str[topr-1]=='(')//当栈顶是右括号，并且临近为左括号，两者一起出栈
    

  612.                 {
    

  613.                         topr--;
    

  614.                         topr--;
    

  615.                 }*/
    

  616.         }
    

  617.                 
    

  618.   }
    

  619.   /*********************压栈函数*********************/
    

  620.   void getTmp(uchar inp)//考虑负号，点，点位置
    

  621.   {
    

  622.           uchar i = 1;
    

  623.           double base = 1;
    

  624.           char tpch[MAX_LEN*2];
    


  625. 

  626.           //tmp = abs(tmp);//可能有副作用------舍去---------------------------------
    

  627.           sprintf(tpch, "%g", tmp);//判断栈顶数正负的准备
    

  628.           if(point==0)//当不存在小数
    

  629.           {
    

  630.                         if(tpch[0]>='0'&&tpch[0]<='9')
    

  631.                                   tmp = tmp*10+inp;
    

  632.                         else
    

  633.                                 tmp = tmp*10-inp;
    

  634.                                 
    

  635.           }
    

  636.           else//当存在小数
    

  637.           {
    

  638.                   //获取小数部分
    

  639.                   for(i=1; i<=pl; ++i)
    

  640.                 {
    

  641.                         base = base/10*1.0;
    

  642.                 }
    

  643.                         if(tpch[0]>='0'&&tpch[0]<='9')
    

  644.                                 tmp = tmp+base*inp;
    

  645.                         else
    

  646.                                 tmp = tmp-base*inp;
    

  647.                 //test-----fixed--------
    

  648.           }
    


  649. 

  650.           if(negative == 1)//存在负号
    

  651.           {
    

  652.                   if(tpch[0]>='0'&&tpch[0]<='9')
    

  653.                         tmp = (-1.0)*tmp;//abs副作用可能----确实，小数点后消失-----------------------
    

  654.           }
    

  655.                   
    


  656. 

  657.                 //test
    

  658.                 //if(topd == 0+0x30)
    

  659.                 test
    


  660. 

  661.                 //test('*');
    

  662.                 
    

  663.                   
    

  664.   }
    

  665.   /*********************显示答案函数*********************/
    

  666.   void showAns()
    

  667.   {
    

  668.     char bun[MAX_LEN*2];
    

  669.         uint m = 0;
    

  670.         tmp *= 1.0;//如果不乘以1.0，会出现小数点后面消失的情况
    


  671. 

  672.           sprintf(bun,"%g",tmp);
    

  673.         while(1)
    

  674.         {
    

  675.               if(bun[m] == '\0')
    

  676.           break;
    

  677.               else
    

  678.                   {
    

  679.                         if(bun[m] == '.'||bun[m] == '-')
    

  680.                                 print(bun[m]);        
    

  681.                         else        
    

  682.                                   print(bun[m]-0x30);
    

  683.                                m++;
    

  684.               }
    

  685.          }
    

  686.   }
    

  687.   /*********************显示答案函数*********************/
    

  688.   void last_cal(double op2, double op1, uchar opr)
    

  689.   {
    

  690.     //计算
    

  691.           if(opr == '+')
    

  692.                 tmp = op2 + op1;
    

  693.         else if(opr == '-')
    

  694.                 tmp = op2 - op1;
    

  695.         else if(opr == '*')
    

  696.                 tmp = op2 * op1;
    

  697.         else if(opr == '/')
    

  698.                 tmp = op2 / op1 * 1.0;
    

  699.         //结果入栈
    

  700.         topd++;
    

  701.         std[topd] = tmp; 
    

  702.   }
    


  703.


回复

举报

相关帖子
发表于 2025-6-30 16:24 | 显示全部楼层
代码已实现了按键输入、LCD 显示和基本状态机框架
回复

举报

发表于 2025-6-30 23:35 | 显示全部楼层
边界情况处理
除零错误：在除法运算时检查除数是否为零
括号匹配：确保左右括号数量一致
运算溢出：检测运算结果是否超出范围
输入长度限制：限制表达式最大长度
回复

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

kkzz

332

主题

11196

帖子

13

粉丝
快速回复 返回顶部 返回列表