简易计算器(加减乘除幂e)

合集下载

简易计算器(1602加矩阵键盘)

简易计算器(1602加矩阵键盘)

一、原理图:二、程序#include<reg51.h> //包含单片机寄存器的头文件#include<intrins.h> //包含_nop_()函数定义的头文件#include<math.h>sbit RS=P2^0; //寄存器选择位,将RS位定义为P2.0引脚sbit RW=P2^1; //读写选择位,将RW位定义为P2.1引脚sbit E=P2^2; //使能信号位,将E位定义为P2.2引脚sbit BF=P1^7; //忙碌标志位,#define NO_KEY_PRESS 0xff/********************************************************************************************************/unsigned char code tab[]={0xb7,0xee,0xde,0xbe,0xed,0xdd,0xbd,0xeb,0xdb,0xbb};unsigned long num1,num2,alg;unsigned char flag;void delay1ms(){unsigned char i,j;for(i=0;i<10;i++)for(j=0;j<15;j++);}/********************************************************************************************************/void delay(unsigned char n){unsigned char i;for(i=0;i<n;i++)delay1ms();}/*****************************************************函数功能:判断液晶模块的忙碌状态返回值:result。

用java代码写的简易计算器(可以实现基本的加减乘除功能)

用java代码写的简易计算器(可以实现基本的加减乘除功能)

⽤java代码写的简易计算器(可以实现基本的加减乘除功能)package A;import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import java.awt.event.MouseEvent;import java.awt.event.MouseListener;import javax.swing.*;public class Calcular3 extends JFrame implements ActionListener,MouseListener{private int m1=0,n=0;//private double m2=0;//运算的数private int flag=0;JFrame f;JPanel p1,p2,p3;JTextField t;JButton b1[]=new JButton[18];String b[]= {"1","2","3","4","5","6","7","8","9","0","清空","退格",".","=","+","-","*","/"};public Calcular3(){f=new JFrame("计算器");t=new JTextField(35);p1=new JPanel();p2=new JPanel();p3=new JPanel();f.setBounds(100, 100, 400, 200);f.add(p1,BorderLayout.NORTH);f.add(p2,BorderLayout.CENTER);f.add(p3,BorderLayout.EAST);p2.setLayout(new GridLayout(5,3));p3.setLayout(new GridLayout(4,1));p1.add(t);for(int i=0;i<14;i++) {b1[i]=new JButton(b[i]);p2.add(b1[i]);b1[i].addActionListener(this);}for(int i=14;i<18;i++) {b1[i]=new JButton(b[i]);p3.add(b1[i]);b1[i].addActionListener(this);}/*for(int i=0;i<18;i++) {b1[i].addActionListener(this);}*/f.setVisible(true);}//实现接⼝的⽅法public void mouseClicked(MouseEvent e) {}public void mousePressed(MouseEvent e) {}public void mouseReleased(MouseEvent e) {}public void mouseEntered(MouseEvent e) {}public void mouseExited(MouseEvent e) {}public void actionPerformed(ActionEvent e) {String str="";int i;for(i=0;i<=9;i++) {if(e.getSource()==b1[i]) {if(i==9) {n=n*10;}else {n=n*10+i+1;}str=String.valueOf(n);//整形n转换成字符串strt.setText(str);//显⽰到⽂本框上}}for(i=14;i<18;i++) {//+、-、*、/if(e.getSource()==b1[i]) {//匹配运算符m1=Integer.parseInt(t.getText());if(flag==15) {m2=m1+m2;}else if(flag==16) {m2=m1-m2;}else if(flag==17) {m2=m1*m2;}else if(flag==18) {m2=m1/m2;}else m2=m1;//若⽆连续的运算符运算,保存当前数据到m2 if(i==14) flag=15;else if(i==15) flag=16;else if(i==16) flag=17;else flag=18;str=String.valueOf(b[i]);t.setText(str);//显⽰到⽂本框上n=0;//还原,记录下次数据break;//找到匹配数据退出循环}}if(e.getSource()==b1[13]) {//=m1=Integer.parseInt(t.getText());if(flag==15) {m2=m2+m1;}else if(flag==16) {m2=m2-m1;}else if(flag==17) {m2=m2*m1;}else if(flag==18) {m2=m2/m1;}else m2=m1;str=String.valueOf(m2);t.setText(str);//显⽰到⽂本框上n=0;//还原,记录下次数据flag=0;//flag还原0,表明没有未处理的运算符}if(e.getSource()==b1[10]) {//各变量变为0 清空m1=0;m2=0;flag=0;n=0;t.setText("0");//显⽰到⽂本框上}if(e.getSource()==b1[11]) {//退格m1=(int)(Double.parseDouble(t.getText())/10);n=m1;str=String.valueOf(m1);t.setText(str);}if(e.getSource()==b1[12]) {//⼩数点m1=Integer.parseInt(t.getText());str=String.valueOf(m1+b[12]);t.setText(str);//显⽰到⽂本框上int j=0;for(i=0;i<=9;i++) {if(e.getSource()==b1[i]) {j++;m2=Math.pow(0.1, j)*Integer.parseInt(b[i]);str=String.valueOf(m1+m2);t.setText(str);//显⽰到⽂本框上}}}}//主函数public static void main(String[] args) {new Calcular3();}}。

简易计算器(源码)

简易计算器(源码)

简易计算器(源码)以下是一个简易计算器的Python源码,用于执行基本的加、减、乘、除运算:```python#简易计算器def add(x, y):"""相加"""return x + ydef subtract(x, y):"""相减"""return x - ydef multiply(x, y):"""相乘"""return x * ydef divide(x, y):"""相除"""if y != 0:return x / yelse:return "除数不能为零!"print("选择操作:")print("1. 相加")print("2. 相减")print("3. 相乘")print("4. 相除")choice = input("输入你的选择(1/2/3/4): ")num1 = float(input("输入第一个操作数: "))num2 = float(input("输入第二个操作数: "))if choice == '1':print(num1, "+", num2, "=", add(num1, num2))elif choice == '2':print(num1, "-", num2, "=", subtract(num1, num2)) elif choice == '3':print(num1, "*", num2, "=", multiply(num1, num2)) elif choice == '4':print(num1, "/", num2, "=", divide(num1, num2)) else:print("无效的选择")```以上代码中,我们定义了四个函数:`add`、`subtract`、`multiply`和`divide`,分别用于执行相加、相减、相乘和相除的操作。

简易计算器

简易计算器

做的一个简易计算器,4X4键盘,1602液晶,一个最小系统,原理图就不给了,看程序也应该知道怎么接线除加减乘除外,有sin,tan,cos,N!,。

等10个附加功能,使用自己摸索。

开始复制了。

对了,是拿别的程序改得,下面是包涵的几个c文件/*-----------------------------------------------名称:LCD1602论坛:编写:shifang日期:2009.5修改:无内容:引脚定义如下:1-VSS 2-VDD 3-V0 4-RS 5-R/W 6-E 7-14 DB0-DB7 15-BLA 16-BLK------------------------------------------------*/#include "1602.h"#include "delay.h"#define CHECK_BUSYsbit RS = P1^0; //定义端口sbit RW = P1^1;sbit EN = P2^5;#define RS_CLR RS=0#define RS_SET RS=1#define RW_CLR RW=0#define RW_SET RW=1#define EN_CLR EN=0#define EN_SET EN=1#define DataPort P0/*------------------------------------------------判忙函数------------------------------------------------*/bit LCD_Check_Busy(void){#ifdef CHECK_BUSYDataPort= 0xFF;RS_CLR;RW_SET;EN_CLR;_nop_();EN_SET;return (bit)(DataPort & 0x80);#elsereturn 0;#endif}/*------------------------------------------------写入命令函数------------------------------------------------*/ void LCD_Write_Com(unsigned char com) {while(LCD_Check_Busy()); //忙则等待RS_CLR;RW_CLR;EN_SET;DataPort= com;_nop_();EN_CLR;}/*------------------------------------------------写入数据函数------------------------------------------------*/ void LCD_Write_Data(unsigned char Data) {while(LCD_Check_Busy()); //忙则等待RS_SET;RW_CLR;EN_SET;DataPort= Data;_nop_();EN_CLR;}/*------------------------------------------------清屏函数------------------------------------------------*/ void LCD_Clear(void){LCD_Write_Com(0x01);DelayMs(5);}/*------------------------------------------------写入字符串函数------------------------------------------------*/void LCD_Write_String(unsigned char x,unsigned char y,unsigned char *s) {while (*s){LCD_Write_Char(x,y,*s);s ++; x++;}}/*------------------------------------------------写入字符函数------------------------------------------------*/void LCD_Write_Char(unsigned char x,unsigned char y,unsigned char Data) {if (y == 0){LCD_Write_Com(0x80 + x);}else{LCD_Write_Com(0xC0 + x);}LCD_Write_Data( Data);}/*------------------------------------------------初始化函数------------------------------------------------*/void LCD_Init(void){LCD_Write_Com(0x38); /*显示模式设置*/DelayMs(5);LCD_Write_Com(0x38);DelayMs(5);LCD_Write_Com(0x38);DelayMs(5);LCD_Write_Com(0x38);LCD_Write_Com(0x08); /*显示关闭*/LCD_Write_Com(0x01); /*显示清屏*/LCD_Write_Com(0x06); /*显示光标移动设置*/DelayMs(5);LCD_Write_Com(0x0C); /*显示开及光标设置*/}延时程序的#include "delay.h"/*------------------------------------------------uS延时函数,含有输入参数unsigned char t,无返回值unsigned char 是定义无符号字符变量,其值的范围是0~255 这里使用晶振12M,精确延时请使用汇编,大致延时长度如下T=tx2+5 uS------------------------------------------------*/void DelayUs2x(unsigned char t){while(--t);}/*------------------------------------------------mS延时函数,含有输入参数unsigned char t,无返回值unsigned char 是定义无符号字符变量,其值的范围是0~255 这里使用晶振12M,精确延时请使用汇编------------------------------------------------*/void DelayMs(unsigned char t){while(t--){//大致延时1mSDelayUs2x(245);DelayUs2x(245);}}按键扫描的/*-----------------------------------------------名称:矩阵键盘论坛:编写:shifang日期:2009.5修改:无内容:------------------------------------------------*/#include<reg52.h> //包含头文件,一般情况不需要改动,头文件包含特殊功能寄存器的定义#include"keyboard.h"#include"delay.h"#define KeyPort P3/*------------------------------------------------按键扫描函数,返回扫描键值------------------------------------------------*/unsigned char KeyScan(void) //键盘扫描函数,使用行列反转扫描法{unsigned char cord_h,cord_l;//行列值中间变量KeyPort=0x0f; //行线输出全为0cord_h=KeyPort&0x0f; //读入列线值if(cord_h!=0x0f) //先检测有无按键按下{DelayMs(10); //去抖if((KeyPort&0x0f)!=0x0f){cord_h=KeyPort&0x0f; //读入列线值KeyPort=cord_h|0xf0; //输出当前列线值cord_l=KeyPort&0xf0; //读入行线值while((KeyPort&0xf0)!=0xf0);//等待松开并输出return(cord_h+cord_l);//键盘最后组合码值}}return(0xff); //返回该值}/*------------------------------------------------按键值处理函数,返回扫键值可以根据需要改变返回值| 1 | 2 | 3 | + || 4 | 5 | 6 | - || 7 | 8 | 9 | * || 0 | . | = | / |------------------------------------------------*/unsigned char KeyPro(void){switch(KeyScan()){case 0x7e:return '1';break;//0 按下相应的键显示相对应的码值case 0x7d:return '2';break;//1case 0x7b:return '3';break;//2case 0x77:return '+';break;//3case 0xbe:return '4';break;//4case 0xbd:return '5';break;//5case 0xbb:return '6';break;//6case 0xb7:return '-';break;//7case 0xde:return '7';break;//8case 0xdd:return '8';break;//9case 0xdb:return '9';break;//acase 0xd7:return 'x';break;//bcase 0xee:return '0';break;//ccase 0xed:return '.';break;//dcase 0xeb:return '=';break;//ecase 0xe7:return '/';break;//fdefault:return 0xff;break;}}主程序/*-----------------------------------------------名称:液晶显示计算器论坛:编写:shifang日期:2009.5修改:无内容:由于单片机浮点数限制,可以计算6位数字运算,大于这个长度,用科学计数法表示小数位精度后6位,大于6位按四舍五入------------------------------------------------*/#include<reg52.h> //包含头文件,一般情况不需要改动,头文件包含特殊功能寄存器的定义#include<stdio.h>#include"1602.h"#include"delay.h"#include"keyboard.h"#include"math.h"unsigned char num,ii,pp,fuhao,i;unsigned char temp[10]; //最大输入16个unsigned char shu[6];unsigned char shu1[6];unsigned char mima[5]={'1','2','3','4','5'};bit firstflag;double n=0,m=0;unsigned char s;bit K,G; //K是两种运算的变换标志位,G是sin元算和加减运算的转换标志bit flag1; //需输入两个数的标志位bit flag2; //输入第二个数的标志位void fuyunsuan (void);void suanshu (void);/*------------------------------------------------阶乘------------------------------------------------*/double jiecheng (unsigned int x )//求阶乘{unsigned int j;double p=1;for (j=1 ; j<=x ; j++ ){p=p*j;}return p ;}/*------------------------------------------------阶和------------------------------------------------*/unsigned int jiehe (float x,float y )//求阶和{unsigned int j,p=0;for (j=x ; j<=y ; j++ ){p=p+j;}return p ;}/*------------------------------------------------输出SIN,COS,TAN....符号并计算------------------------------------------------*/void fuyunsuan (void)//{if(('+'==num)|| ('-'==num) || ('x'==num)|| ('/'==num) || ('.'==num))//判断第一个是否为符号{K=~K; //取反是为了,没按一次键,转换一次运算LCD_Clear(); //清屏if(num=='+') //‘+’复用的功能改变,下面的同理{if(K==0){LCD_Write_String(0,0,"SIN :"); fuhao=1;flag1=0;}if(K==1){LCD_Write_String(0,0,"COS :"); fuhao=2;flag1=0;}}if(num=='-'){if(K==0){LCD_Write_String(0,0,"TAN :"); fuhao=3;flag1=0;}if(K==1){LCD_Write_String(0,0,"LOG :"); fuhao=4; flag1=1;}}if(num=='x'){if(K==0){LCD_Write_String(0,0,"N^M :"); fuhao=5;flag1=1;}if(K==1){LCD_Write_String(0,0,"root:"); fuhao=6;flag1=0;}}if(num=='/'){if(K==0){LCD_Write_String(0,0,"E^ :"); fuhao=7;flag1=0;}if(K==1)LCD_Write_String(0,0,"LG E:");fuhao=8;flag1=0;}}if(num=='.'){if(K==0){LCD_Write_String(0,0,"N+ :");fuhao=9;flag1=1;}if(K==1){LCD_Write_String(0,0,"N! :");fuhao=10;flag1=0;}}LCD_Write_Com(0x80 + 5);//为了输入的数据定好位置}else{if('='!=num) //判定是否为‘=‘号,不是就取数据,是就进行运算{if(flag2!=1) //取第一个数据{shu[ii]=num-0x30;LCD_Write_Data(num);num=0xff;ii++;}else //取第二个数据,前提的是要输入第二个,并且按过一次等号{shu1[pp]=num-0x30;LCD_Write_Data(num);num=0xff;pp++;}}else //这边的else已经是为=号的情况了if(flag1==1&&shu[0]!=0) //这是判定第二次=号的功能的,flag=1就是要输入第二个数,并且已经输入第一个数{ //这里让flag2=1,看上面,是不是就可以去第二个数了flag2=1;flag1=0;if(fuhao==4)LCD_Write_Data('-');if(fuhao==5)LCD_Write_Data('^');if(fuhao==9)LCD_Write_Data('~');}else //这边当然是搞结果的啦{for(s=0;s<ii;s++) //n=n+shu[s]*pow(10,ii-s-1); //把前面输入的数据,处理一下,赋值给nfor(s=0;s<pp;s++) //m=m+shu1[s]*pow(10,pp-s-1); //把输入的第二组数据给mfor(ii=0;ii<6;ii++) //赋值完成后把缓冲区清零,防止下次输入影响结果shu[ii]=0;for(pp=0;pp<6;pp++) //赋值完成后把缓冲区清零,防止下次输入影响结果shu[pp]=0;ii=0;pp=0;switch(fuhao) //通过符号的值运算,前面的fuhao终于有用了吧{case 1 :n=sin((3.1415926/180)*n);break;case 2 :n=cos((3.1415926/180)*n);break;case 3 :n=tan((3.1415926/180)*n);break;case 4 :n=log(m) / log(n);break;case 5 :n=pow(n,m);break;case 6 :n=sqrt(n);break;case 7 :n=exp(n);break;case 8 :n=log(n);break;case 9 :n=jiehe(n,m);break;case 10 :n=jiecheng(n);break;default:break;}for(s=0;s<10;s++) //赋值完成后把缓冲区清零,防止下次输入影响结果temp[s]=0;LCD_Write_Char(0,1,num);sprintf(temp,"%g",n); //输出浮点型,无用的0不输出LCD_Write_String(1,1,temp);//显示到液晶屏for(s=0;s<16;s++) //赋值完成后把缓冲区清零,防止下次输入影响结果temp[s]=0;flag1=0;flag2=0; n=0;m=0;G=0; //输出完之后,以后还要混的,清理现场先LCD_Write_Com(0x0C);}}}}/*------------------------------------------------加减乘除------------------------------------------------*/void suanshu (void){if(i==0) //输入是第一个字符的时候需要把改行清空,方便观看LCD_Clear();if(('+'==num)|| (i==16) || ('-'==num) || ('x'==num)|| ('/'==num) || ('='==num))//输入数字最大值16,输入符号表示输入结束{i=0; //计数器复位if(firstflag==0) //如果是输入的第一个数据,赋值给a,并把标志位置1,到下一个数据输入时可以跳转赋值给b{sscanf(temp,"%f",&n);firstflag=1;}elsesscanf(temp,"%f",&m);for(s=0;s<16;s++) //赋值完成后把缓冲区清零,防止下次输入影响结果temp[s]=0;LCD_Write_Char(0,1,num);///////////////////////if(num!='=') //判断当前符号位并做相应处理fuhao=num; //如果不是等号记下标志位else{firstflag=0; //检测到输入=号,判断上次读入的符合switch(fuhao){case '+':n=n+m;break;case '-':n=n-m;break;case 'x':n=n*m;break;case '/':n=n/m;break;default:break;}sprintf(temp,"%g",n); //输出浮点型,无用的0不输出LCD_Write_String(1,1,temp);//显示到液晶屏fuhao=0;n=m=0; G=0; //用完后所有数据清零for(s=0;s<16;s++)temp[s]=0;shu[0]=0;shu1[0]=0;LCD_Write_Com(0x0C);}}else if(i<16){if((1==i)&& (temp[0]=='0') )//如果第一个字符是0,判读第二个字符{if(num=='.') //如果是小数点则正常输入,光标位置加1{temp[1]='.';LCD_Write_Char(1,0,num);//输出数据i++;} //这里没有判断连续按小数点,如0.0.0else{temp[0]=num; //如果是1-9数字,说明0没有用,则直接替换第一位0LCD_Write_Char(0,0,num);//输出数据LCD_Write_Com(0x0e);}}else{temp[i]=num;LCD_Write_Char(i,0,num);//输出数据i++; //输入数值累加}}}/*------------------------------------------------输入密码------------------------------------------------*/void mimashuru (void){while(K){for(i=0;i<5;){num=KeyPro(); //扫描键盘if(num!=0xff){shu[i]=num;LCD_Write_Data('*');i++;}}for(i=0;i<5;i++){if(shu[i]==mima[i])pp++;}if(pp==5){K=0;}else{LCD_Clear();pp=0;LCD_Write_String(0,0," NO! NO! NO!"); //写入第一行信息,主循环中不再更改此信息,所以在while之前写入LCD_Write_String(0,1,"Password:"); //写入第二行信息,提示输入密码}}for(s=0;s<25;s++)//延时5sDelayMs(200);LCD_Clear();LCD_Write_Com(0x0C);LCD_Write_String(0,0," Well done"); //写入第一行信息,主循环中不再更改此信息,所以在while之前写入i=0;pp=0;shu[0]=0;for(s=0;s<25;s++)//延时5sDelayMs(200);LCD_Clear();}/*------------------------------------------------主程序------------------------------------------------*/main(){K=1;ii=0;pp=0;flag1=0;flag2=0;i=0;G=0;LCD_Init(); //初始化液晶屏DelayMs(10); //延时用于稳定,可以去掉LCD_Clear(); //清屏LCD_Write_String(0,0,"Welcome2 my work"); //写入第一行信息,主循环中不再更改此信息,所以在while之前写入LCD_Write_String(0,1,"HYJ Productions"); //写入第二行信息,提示输入密码for(s=0;s<75;s++)//延时5sDelayMs(200);LCD_Clear();LCD_Write_String(0,0,"Please enter your"); //写入第一行信息,主循环中不再更改此信息,所以在while之前写入LCD_Write_String(0,1,"Password:"); //写入第二行信息,提示输入密码LCD_Write_Com(0x0f);//光标开,光标闪烁开mimashuru();LCD_Write_Com(0x0f);//光标开,光标闪烁开while (1) //主循环{num=KeyPro(); //扫描键盘if(num!=0xff){LCD_Write_Com(0x0f);//光标开,光标闪烁开if((('+'==num)||('-'==num) || ('x'==num)|| ('/'==num) || ('.'==num))&&shu[0]==0&&shu1[0]==0&&temp[0]==0)G=1; //判定第一个按键是否为功能键if(G==1){fuyunsuan ();}else{suanshu();}}}}结束语,初学者的劳动成果啊,不容易啊,我试过,程序没问题,就是有些小瑕疵,不过懒得弄了,这程序也很容易仿真,那I/O自己改吧,得。

简易计算器设计说明书

简易计算器设计说明书

摘要单片机的出现是计算机制造技术高速发展的产物,它是嵌入式控制系统的核心。

如今,它已广泛的应用到我们生活的各个领域,电子、科技、通信、汽车、工业等。

计算器的出现给我们的生活带来了巨大的便利,计算器在我们的生活中随处可见,也是我们日常生活中不可缺少的工具。

本设计是基于51系列单片机来进行的数字计算器系统设计,可以完成计算器的键盘输入,进行加、减、乘、除简单的基本四则运算,并在LCD上显示相应的结果。

设计电路采用AT89C51单片机为主要控制电路,利用按键作为计算器的键盘的输入。

显示采用字符LCD 静态显示。

软件方面使用C语言编程,并用PROTUES仿真。

单片微型计算机简称单片机。

它是在一块芯片上集成中央处理器(CPU)、随机存取存储器(RAM)、只读存储器(ROM)、定时/计数器及I/O接口电路等部件,构成一个完整的微型计算机。

它的特点是:高性能,高速度,体积小,价格低廉,稳定可靠,应用广泛。

单片机比专用处理器最适合应用于嵌入式系统,因此它得到了最多的应用。

本文介绍了单片机的产生发展、功能特点、应用开发等内容。

【关键词】简单计算器单片机 LCD 应用发展背景近年来,单片机以其体积小、价格廉、面向控制等独特优点,在各种工业控制、仪器仪表、设备、产品的自动化、智能化方面获得了广泛的应用。

与此同时,单片机应用系统的可靠性成为人们越来越关注的重要课题。

影响可靠性的因素是多方面的,如构成系统的元器件本身的可靠性、系统本身各部分之间的相互耦合因素等。

其中系统的抗干扰性能是系统可靠性的重要指标。

本设计采用80c51 芯片,实现了利用单片机进行了一个简单计算器设计。

允许对输入数据进行加减乘除运算及LCD 显示.如果设计对象是更为复杂的计算器系统,其实际原理与方法与本设计基本相同。

LCD液晶显示器是Liquid Crystal Display 的简称,LCD 的构造是在两片平行的玻璃基板当中放置液晶盒,下基板玻璃上设置TFT(薄膜晶体管),上基板玻璃上设置彩色滤光片,通过TFT上的信号与电压改变来控制液晶分子的转动方向,从而达到控制每个像素点偏振光出射与否而达到显示目的。

超级简易的JS计算器(实现加减乘除)

超级简易的JS计算器(实现加减乘除)

超级简易的JS计算器(实现加减乘除)<!DOCTYPE html><html><head><meta charset="UTF-8"><title>简单的计算器</title><style>body{margin: 0;}.tab{border: 3px solid black ;border-radius: 2px;border-collapse:collapse;width: 268px;height: 402px;margin: 100px auto;}.tr{height: 67px;width: 268px;border: 3px solid black ;text-align: right;}.tr1{width: 268px;height: 67px;border: 3px solid black ;text-align: center;}.tr2{width: 67px;height: 67px;border: 3px solid black ;text-align: center;}</style><script>var s1 = "";var s2 = "";var s3 = "";var s4 = "";var s5 = "";function view(val){var a = document.getElementById(val);s1 = a.innerHTML;if(s1=="+" || s1=="-" || s1=="*" || s1=="/"){s3 = s1;s1 = "";}if(s3=="+" || s3=="-" || s3=="*" || s3=="/"){add2(s1);}if(s3==""){add1(s1);}}function add1(s1){s2 = s2 + s1;show();}function add2(s1){s4 = s4 + s1;show();}function cal(){switch(s3){case "+":{s5 = (String)((parseFloat(s2)+parseFloat(s4)).toFixed(2));result.innerHTML = s5;break;}case "-":{s5 = (String)((parseFloat(s2)-parseFloat(s4)).toFixed(2));result.innerHTML = s5;break;}case "*":{s5 = (String)((parseFloat(s2)*parseFloat(s4)).toFixed(2));result.innerHTML = s5;break;}case "/":{s5 = (String)((parseFloat(s2)/parseFloat(s4)).toFixed(2));result.innerHTML = s5;break;}}}function show(){var result = document.getElementById("result");result.innerHTML = s2+s3+s4;}</script></head><body><table class="tab"><tr class = "tr2"><td colspan="4">简易计算器</td></tr><tr class="tr"><td id="result" colspan="4"></td></tr><tr ><td id="+" class="tr1" onclick="view('+')">+</td><td id="-" class="tr1" onclick="view('-')">-</td><td id="*" class="tr1" onclick="view('*')">*</td><td id="/" class="tr1" onclick="view('/')">/</td></tr><tr ><td id="7" class="tr1" onclick="view('7')">7</td><td id="8" class="tr1" onclick="view('8')">8</td><td id="9" class="tr1" onclick="view('9')">9</td><td id="0" class="tr1" onclick="view('0')">0</td></tr><tr><td id="4" class="tr1" onclick="view('4')">4</td><td id="5" class="tr1" onclick="view('5')">5</td><td id="6" class="tr1" onclick="view('6')">6</td><td id="." class="tr1" onclick="view('.')">.</td></tr><tr><td id="1" class="tr1" onclick="view('1')">1</td><td id="2" class="tr1" onclick="view('2')">2</td><td id="3" class="tr1" onclick="view('3')">3</td><td id="=" class="tr1" onclick="cal()">=</td></tr></table></body></html>对于这个程序来说,判断的顺序⾮常重要,不然就会把"+"号存在s2,s4中⽽不是s3中。

计算器编程实例

计算器编程实例

按键和液晶,可以组成我们最简易的计算器。

下面我们来写一个简易整数计算器提供给大家学习。

为了让程序不过于复杂,我们这个计算器不考虑连加,连减等连续计算,不考虑小数情况。

加减乘除分别用上下左右来替代,回车表示等于,ESC 表示归 0。

程序共分为三部分,一部分是 1602 液晶显示,一部分是按键动作和扫描,一部分是主函数功能。

/***************************Lcd1602.c 文件程序源代码*****************************/ #include <reg52.h>#define LCD1602_DB P0sbit LCD1602_RS = P1^0;sbit LCD1602_RW = P1^1;sbit LCD1602_E = P1^5;/* 等待液晶准备好 */void LcdWaitReady(){unsigned char sta;LCD1602_DB = 0xFF;LCD1602_RS = 0;LCD1602_RW = 1;do {LCD1602_E = 1;sta = LCD1602_DB; //读取状态字LCD1602_E = 0;} while (sta & 0x80); //bit7 等于 1 表示液晶正忙,重复检测直到其等于 0 为止}/* 向 LCD1602 液晶写入一字节命令,cmd-待写入命令值 */void LcdWriteCmd(unsigned char cmd){LcdWaitReady();LCD1602_RS = 0;LCD1602_RW = 0;LCD1602_DB = cmd;LCD1602_E = 1;LCD1602_E = 0;}/* 向 LCD1602 液晶写入一字节数据,dat-待写入数据值 */void LcdWriteDat(unsigned char dat){LcdWaitReady();LCD1602_RS = 1;LCD1602_RW = 0;LCD1602_DB = dat;LCD1602_E = 1;LCD1602_E = 0;}/* 设置显示 RAM 起始地址,亦即光标位置,(xy)-对应屏幕上的字符坐标 */ void LcdSetCursor(unsigned char x unsigned char y){unsigned char addr;if (y == 0) //由输入的屏幕坐标计算显示 RAM 的地址addr = 0x00 + x; //第一行字符地址从 0x00 起始elseaddr = 0x40 + x; //第二行字符地址从 0x40 起始LcdWriteCmd(addr | 0x80); //设置 RAM 地址}/* 在液晶上显示字符串,(xy)-对应屏幕上的起始坐标,str-字符串指针 */ void LcdShowStr(unsigned char x unsigned char y unsigned char *str){LcdSetCursor(x y); //设置起始地址while (*str != '\0') //连续写入字符串数据,直到检测到结束符{LcdWriteDat(*str++);}}/* 区域清除,清除从(xy)坐标起始的 len 个字符位 */void LcdAreaClear(unsigned char x unsigned char y unsigned char len){LcdSetCursor(x y); //设置起始地址while (len--) //连续写入空格{LcdWriteDat(' ');}}/* 整屏清除 */void LcdFullClear(){LcdWriteCmd(0x01);}/* 初始化 1602 液晶 */void InitLcd1602(){LcdWriteCmd(0x38); //16*2 显示,5*7 点阵,8 位数据接口LcdWriteCmd(0x0C); //显示器开,光标关闭LcdWriteCmd(0x06); //文字不动,地址自动+1LcdWriteCmd(0x01); //清屏}Lcd1602.c 文件中根据上层应用的需要增加了2 个清屏函数:区域清屏——LcdAreaClear,整屏清屏——LcdFullClear。

Python之实现一个简易计算器

Python之实现一个简易计算器

Python之实现⼀个简易计算器⾃⼰动⼿写计算器⼀、功能分析 ⽤户输⼊⼀个类似这样 3*( 4+ 50 )-(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4) 这样的表达式,假设表达式⾥⾯除了包含空格、'+'、'-'、'*'、'/'和括号再⽆其他特殊符号,然后⾃⼰动⼿写代码解析其中的表达式,实现加减乘除,最后得出的结果与真实的计算机所算的结果必须⼀致。

⼆、所需的知识点字符串的处理正则表达式的运⽤函数递归三、程序实现流程分析1. ⽤正则表达式处理字符串,只提取其中的数字和运算符,并转换成列表2. 编写⼀个函数,处理没有括号的基本运算的基本表达式3. 再写⼀个函数递归处理带有括号的函数,先计算最内部括号中的表达式, 然后将最内部的括号替换为计算后的结果, 在递归外部⼀层的,最后返回的就是所需的结果四、具体实现过程1.正则表达式处理⽤户输⼊字符串 这⾥我不会讲正则表达式具体的⽤法,要将的话都可以讲⼀本书了,我只讲本⽂⽤到的正则表达式。

根据需求,我们需要提取出⽤户输⼊字符串中的数字和运算符到⼀个列表中,⽽空格将会被忽略掉,假设⽤户输⼊的表达式是 expression,我们可以写出下⾯的代码:1 2 3 4import reexpression='(( 100 + 40 )*5/2- 3*2* 2/4+9)*((( 3 + 4)-4)-4)'l=re.findall('([\d\.]+|/|-|\+|\*)',expression)print(l) #['100', '+', '40', '*', '5', '/', '2', '-', '3', '*', '2', '*', '2', '/', '4', '+', '9', '*', '3', '+', '4', '-', '4', '-', '4'] ⾸先我们先看⼀下 findall 的⽤法,findall可以匹配所有符合规律的内容,返回包含结果的列表。

简易计算器(二叉树)

简易计算器(二叉树)

实验三——简易计算器(二叉树)05111341班李凌豪 11201312631.需求分析1.1.问题重述(1)问题描述由键盘输入一算术表达式,以中缀形式输入,试编写程序将中缀表达式转换成一棵二叉表达式树,通过对该的后序遍历求出计算表达式的值。

(2)基本要求a.要求对输入的表达式能判断出是否合法。

不合法要有错误提示信息。

b.将中缀表达式转换成二叉表达式树。

c.后序遍历求出表达式的值(3)数据结构与算法分析一棵表达式树,它的树叶是操作数,如常量或变量名字,而其他的结点为操作符。

a.建立表达式树。

二叉树的存储可以用顺序存储也可用链式存储。

当要创建二叉树时,先从表达式尾部向前搜索,找到第一个优先级最低的运算符,建立以这个运算符为数据元素的根结点。

注意到表达式中此运算符的左边部分对应的二叉绔为根结点的左子树,右边部分对应的是二叉绔为根结点的右子树,根据地这一点,可用递归调用自己来完成对左右子树的构造。

b.求表达式的值。

求值时同样可以采用递归的思想,对表达式进行后序遍历。

先递归调用自己计算左子树所代表的表达式的值,再递归调用自己计算右子树代表的表达式的值,最后读取根结点中的运算符,以刚才得到的左右子树的结果作为操作数加以计算,得到最终结果。

(4)测试1.2.问题分析本实验要求我们编写一个程序,利用二叉树,实现简易计算器的功能。

实现实数范围内的四则混合运算,而且要考虑括号对运算顺序的影响。

而且,题目要求用二叉树的知识来实现程序功能,因此需要将输入的中序表达式转换成逆波兰序列,然后就以此序列建立二叉链表,之后通过后序遍历实现运算的功能。

大概要求就是这样的。

2.概要设计2.1.抽象数据类型的定义考虑到,算符为字符型变量,算数为单精度浮点型变量。

考虑先讲输入的浮点数替换为char型的符号。

Struct jd为二叉链表的节点类型。

每一个节点都有字符域data,数字的话会有数值域shuzi为单精度浮点数。

struct jd{char data;float shuzi;struct jd *next1;struct jd *next2;};Struct haha 类型的数组ka[20]用来存放运算数,如果是运算数,就存进来,然后用字符域fuhao来代替数值域的单精度shuzi。

简单介绍简易计算器的使用方法

简单介绍简易计算器的使用方法

简单介绍简易计算器的使用方法简易计算器使用方法计算器是我们日常生活中常见的小工具之一,它能够方便快捷地完成各种数学运算。

在本文中,我们将简单介绍一下简易计算器的使用方法,帮助大家更好地利用这个小工具。

一、开机与关闭使用简易计算器之前,首先需要开机。

通常,在计算器上会有一个电源开关,打开开关后,计算器便会自动启动。

要关闭计算器,只需要将电源开关关闭即可。

二、数字输入在简易计算器上,数字输入是最基本的操作。

计算器通常会有一个数字键盘,上面标有0到9的数字。

通过按下相应的数字键,可以输入需要计算的数值。

输入多位数时,只需按照正确的顺序依次按下每个数字键。

三、基本运算简易计算器能够完成四则运算,包括加法、减法、乘法和除法。

使用计算器进行基本运算时,需要按下特定的运算符键。

1. 加法:简易计算器上通常会有一个“+”键,按下该键后,计算器会把当前输入的数值记为被加数,再输入另一个数值,按下“=”键,计算器就会显示它们的和。

2. 减法:类似地,简易计算器上通常会有一个“-”键,按下该键后,计算器会把当前输入的数值记为被减数,再输入一个数值,按下“=”键,计算器就会显示它们的差。

3. 乘法:简易计算器上通常会有一个“×”键,按下该键后,计算器会把当前输入的数值记为被乘数,再输入一个数值,按下“=”键,计算器就会显示它们的积。

4. 除法:类似地,简易计算器上通常会有一个“÷”键,按下该键后,计算器会把当前输入的数值记为被除数,再输入一个数值,按下“=”键,计算器就会显示它们的商。

四、小数与分数计算除了整数运算,简易计算器还可以进行小数和分数的计算。

对于小数的输入,直接使用数字键盘即可,对于分数的输入,则需要使用特定的输入方式。

通常,在计算器上会有一个“分数”键或“1/x”键,按下该键后,计算器会进入分数输入模式,在屏幕上显示分子和分母的输入框,通过按下数字键来输入相应的分子和分母。

输入完毕后,按下“=”键,计算器就会进行分数的计算。

简易计算器

简易计算器

摘要近年来随着科技的飞速发展,单片机的应用正在不断深入,同时带动传统控制检测技术日益更新。

在实时检测和自动控制的单片机应用系统中,单片机往往作为一个核心部件来使用,仅单片机方面知识是不够的,还应根据具体硬件结构软硬件结合,加以完善。

计算器是人们的日常最常见的电子产品之一,它应用极广,发展迅猛,并且不断出现着拥有强大功能的计算器。

此次课程设计实现四位数的加减乘除运算的简易计算器,实现键盘输入,程序都是根据教材内和网络中的程序参考编写而成,在功能上还并不十分完善,限制也较多。

完成的计算器经过检验能够完整的实现预设功能,各种细节完善。

具有很高的使用价值。

目录摘要 (1)第一章设计要求 (2)第二章设计思路及原理图 (2)a 思路 (2)b 原理图 (2)c 单片机引脚图 (3)第三章程序图 (3)第四章源程序 (4)第五章课程设计的心得体会 (10)第一章设计要求本次的设计是利用单片机设计简单的计算器,本设计利用单片机的I/O接口设计4×4键盘,8个键依次对应0~3、“+”、“-”、“=”和清除键。

通过检测不同数字键、功能键的按下,可以进行加减乘除运算,并可连续运算。

对应每一个数字键按下的同时,LED显示按下键的值,并显示最后的运算结果。

试验设备:8051单片机、七段四显示数码管一个、导线若干、12MHz晶振一个、计算机。

第二章设计思路及原理图a 思路:首先初始化参数,送LED低位显示“0”,高位不显示。

然后扫描键盘看是否有键输入,若有,读取键码。

判断键码是数字键、清零键还是功能键(“+”“-”“*”“/”“=”),是数值键则送LED显示并保存数值,是清零键则做清零处理,是功能键则又判断是“=”还是运算键,若是“=”则计算最后结果并送LED显示,若是运算键则保存相对运算程序的首地址。

利用单片机的I/O接口设计4×4键盘,两行四列分别由单片机的P2.4\P2.5及P2.0-P2.3输入输出数据。

C语言实现简易计算器(可作加减乘除)

C语言实现简易计算器(可作加减乘除)

C语⾔实现简易计算器(可作加减乘除)C语⾔实现简易计算器(加减乘除)计算器作为课设项⽬,已完成答辩,先将代码和思路(注释中)上传⼀篇博客已增添、修改、整理⾄⽆错且可正常运⾏虽使⽤了栈,但初学者可在初步了解栈和结构语法后理解代码#include <stdlib.h>#include <stdio.h>#include <string.h>#define IsDouble 0#define IsChar 1//_______________________________________________________________________________________________________________________________________________________ //1.⽀持浮点数和字符的栈typedef struct {char * buffer;int typesize;int top;int max;} stack;stack * CreateStack(int max, int typesize);//创建⼀个栈void DestroyStack(stack *);//释放栈的空间void ClearStack(stack *);//清空栈int Push(stack *, void *);//⼊栈int Pop(stack *, void *);//出栈int GetSize(stack *s);//得到栈的⼤⼩int GetTop(stack *, void *);//找到栈顶int IsEmpty(stack *);//判断是否为空栈,空则下溢int IsFull(stack *);//判断栈是否已满,满则溢出stack * CreateStack(int max, int typesize){stack * s = (stack*)malloc(sizeof(stack));//为栈s malloc内存if (!s) return 0;//为结构中buffer元素malloc内存s->buffer = (char *)malloc(sizeof(char) * max * typesize);if (!s->buffer) return 0;//初始化结构中的栈顶,最⼤值,类型⼤⼩s->top = -1;s->max = max;s->typesize = typesize;return s;}void DestroyStack(stack* s){free(s->buffer);//先释放buffer的空间free(s);//在释放s的空间}void ClearStack(stack * s){s->top = -1;//清空栈(栈头位置归零)}int Push(stack * s, void * data){if (IsFull(s)) return 0;//如果栈已满则return 0,防⽌溢出//栈未满则将栈头移动打动下⼀位置,并将data中的元素拷⼊栈中buffer的第top位置s->top++;memcpy(s->buffer + s->top*s->typesize, data, s->typesize);//⼊栈成功return 1return 1;}int Pop(stack * s, void * data){if (IsEmpty(s)) return 0;//出栈判断栈是否为空,若为空则return 0//栈未空则将buffer中top位置的字符拷⼊data记录,并让栈头向前移动⼀个位置memcpy(data, s->buffer + s->top*s->typesize, s->typesize);s->top--;//成功则return 1return 1;}int GetSize(stack *s){return s -> top+1;//栈头位置+1得到⼤⼩}int GetTop(stack *s, void * data){if (IsEmpty(s)) return 0;//如果栈空return 0//栈不为空则将top位置的字符拷回data记录,得到栈头memcpy(data, s->buffer + s->top*s->typesize, s->typesize);//成功则return 1;return 1;}int IsEmpty(stack * s){return s->top == -1;//如果top为-1则栈空}int IsFull(stack * s){return s->top == s->max-1;//如果top为max-1则栈满}//___________________________________________________________________________________________________________________________________________________ //2.定义⼀个cal类型,其中data存数时sign为IsDouble,存字符时,sign为Ischartypedef struct {double data;char sign;} cal;//3.查找对应符号(找到则返回该符号下标)(找不到则说明该部分为数字返回-1)int SearchCode(char ch){char * code = "+-*/()@";//@为终⽌符,算式输⼊结束int index = 0;//while (code[index]){if (code[index] == ch) return index;index++;}return -1;}//4.得到两个符号间的优先级//与SearchCode相对应,char GetPriority(char ch, char next){//创建⼀个perferen表,第i⾏(列)对应SearchCode函数中code中的第i个字符char perferen[7][7] = {">><<<>>",">><<<>>",">>>><>>",">>>><>>","<<<<<=E",">>>>E>>","<<<<<E="};//找到两个形参对应的字符int c = SearchCode(ch);int n = SearchCode(next);//如果找不到对应运算符(字符不是运算符⽽是为数字)return Eif (c==-1 || n==-1) return 'E';//如果找到两个对应运算符则按照优先级表返回两个运算符的优先级return perferen[c][n];}//5.四则运算double add(double a, double b) { return a+b; }double sub(double a, double b) { return a-b; }double mul(double a, double b) { return a*b; }double ddiv(double a, double b) { return a/b; }//整合四种运算double calcu(double a, char ch, double b){double (*calculation[4])(double,double) = {add,sub,mul,ddiv};return calculation[SearchCode(ch)](a,b);}//6.检测字符串int CheckStr(char * buffer){int n;//遍历字符串确保算式中⽆⾮法字符若检测到⾮法字符return 0,若都合法则return 1for (n = 0;buffer[n];n++){if ((SearchCode(buffer[n]) != -1 || buffer[n] == '.' || (buffer[n] >= '0' && buffer[n] <= '9')) && buffer[n] != '@') continue;else return 0;}buffer[n] = '@';//加上终⽌符,表⽰算式结束buffer[n+1] = '\0';return 1;}//7.得到数据转化为double类型存⼊rsint GetDigit(char * buffer, int * n, double * rs){char str[30];int i,j = 0;for (i = 0;SearchCode(buffer[*n]) == -1;i++){str[i] = buffer[*n];//从*n位置开始,将这⼀串数字字符存⼊str(*n)++;}str[i] = '\0';for (i = 0;str[i];i++){if (str[i] == '.') j++;}//如果⼀段⼩数有多个⼩数点或⼩数点在数字⾸尾,return 0if (j>1 || str[i-1] == '.' || str[0] == '.') return 0;//rs接收转化为double的数据*rs = atof(str);//操作成功return 1return 1;}//8.将⽤户输⼊的buffer字符串转化为可供程序运算的calstr数组int resolu(char * buffer, cal * calstr){int i = 0, j = 0;cal c;while (buffer[i]){if (SearchCode(buffer[i]) == -1){//如果得到数据不成功则return 0if (GetDigit(buffer,&i, &c.data) == 0) return 0;//如果成功得到数据则在c.sign标记为浮点数c.sign = IsDouble;//将c存⼊数组calstr中calstr[j++] = c;}else{//若符号为运算符//判断正负号if (buffer[i] == '-' && (buffer[i-1] == '('||buffer[i-1] == '+'||buffer[i-1] == '-'||buffer[i-1] == '*'||buffer[i-1] == '/') || (i==0 && buffer[0] == '-')){ i++;if (GetDigit(buffer,&i, &c.data) == 0) return 0;//在符号的下⼀位开始查找,若找不到数字return 0//否则,给数字取相反数,c.sign标记为浮点数,存⼊calstr中c.data = 0 - c.data;c.sign = IsDouble;calstr[j++] = c;} else//如果是正号,与符号处理⽅式同理if (buffer[i] == '+' && (buffer[i-1] == '('||buffer[i-1] == '+'||buffer[i-1] == '-'||buffer[i-1] == '*'||buffer[i-1] == '/') || (i==0 && buffer[0] == '+')){ i++;if (GetDigit(buffer, &i, &c.data) == 0) return 0;c.sign = IsDouble;calstr[j++] = c;}else{//如果不是正负号,则为运算符,先强制转换为double类型存在c.data⾥,然后c.sign标记为char类型,存⼊calstrc.data = (double)buffer[i++];c.sign = IsChar;calstr[j++] = c;}}}//操作蔡成功则return 1return 1;}//9.计算出结果int result(cal * calstr, double * rs){stack * pst = CreateStack(100,sizeof(char));//运算符栈stack * pnd = CreateStack(100,sizeof(double));//数据栈double num1,num2;int n = 0;char ch = '@';Push(pst, &ch);//在转换得到的calstr中遍历直到终⽌符'@"while(ch != '@' || !(calstr[n].sign == IsChar && (char)calstr[n].data == '@')){//如果calstr的n位上是浮点数,则将这个data压栈进⼊数据栈pnd中if (calstr[n].sign == IsDouble){Push(pnd, &(calstr[n].data));n++;}//反之,如果是运算符,则要检测优先级else{switch( GetPriority(ch, (char)calstr[n].data)){//如果运算符优先级较⼩,则让ch等于优先级⼤的符号并压⼊符号栈pst中case '<':ch = (char)calstr[n].data;Push(pst, &ch);n++;break;//如果结果为等号,让符号出栈暂存到ch中case '=':if (!Pop(pst, &ch)) return 0;n++;break;//如果ch优先级较⾼,则将前两个数字及运算符出栈,分别储存⾄num2,ch,num1中,进⾏运算,得到的结果再次压栈进⼊pnd中 case '>':if (!(Pop(pnd,&num2) && Pop(pst,&ch) && Pop(pnd,&num1))) return 0;num1 = calcu(num1,ch,num2);Push(pnd, &num1);break;//如果符号顺序出错,return 0case 'E':return 0;}}//检测是否可以得到栈顶符号,栈空则return 0if (!GetTop(pst, &ch)) return 0;}//如果栈中得到了最终结果,并且取出pnd中的最终结果到rs,return 1if (GetSize(pnd) == 1 && GetTop(pnd,rs)){DestroyStack(pst);DestroyStack(pnd);return 1;}//否则 return 0else{return 0;}}//10.⽤户交互函数void treatment(){char buffer[100];//⽤户输⼊的字符串(算式)cal calstr[50];//计算⽤的数组double rs = 0;//计算结果printf("Enter your equation:");gets(buffer);//让⽤户输⼊算式buffer//⽤户不输⼊"exit"就不退出while (!(buffer[0]=='e' && buffer[1]=='x' && buffer[2]=='i' && buffer[3]=='t')){//检查buffer中字符君合法,成功将buffer转化为⽤于计算的calstr数组,成功计算出结果存⼊rsif (CheckStr(buffer) && resolu(buffer,calstr) && result(calstr,&rs)){printf("\n%lf\n",rs);}else{printf("\nError!\n");}printf("Enter \"exit\"to quit");printf("\nEnter your equation:");gets(buffer);//再次让⽤户输⼊算式}printf("\nbye\n");}//11.主函数int main(){treatment();}参考⽂献链接如下[参考⽂献]()。

简易计算器 带小数点

简易计算器 带小数点

简易计算器(带小数点)一.主要实现功能1.能完成五位数以内的加减乘除运算(其中整数部分最多为3位,小数部分最多为2位,多余的输入无效)。

2.运算结果数码管显示。

3.在进行减法运算时,如果差是负数,数码管能够显示负数。

4.能及时显示输入的值和运算的结果二.操作方法(类似普通的计算器)显示板上的1--9数字键作为运算是数字的输入,上档键作为加法键,下档键作为减法键,左键作为乘法键,右键作为除法键,Esc键是取消键,用来取消上一次的操作或是返回上一状态。

Enter键在数字输入时作为小数点的键入键,当完成第二个的数输入后,Enter键则作为计算器中的“=”键,得出运算的结果,并且在数码管上显示,其余的操作步骤与方法与普通的计算器类似。

三.程序流程图1.思想从计算器的操作步骤来看,可以把计算器的输入过程分解由四个状态来实现,如下图所示第一个数的输入加减乘除键的输入Enter键得结果第二个数的输入与整数计算器不同的是,带小数的计算器要完成小数点的键入,须记录小数点后面的位数,所以我们又可以把数字的输入分为两个状态,一个是整数部分的键入,另一个是小数部分的键入。

如下所示:数字的输入整数的输入小数的输入程序流程图由程序流程图可以画出程序流程图0 1 2 3以上只是从整体把握计算器程序,也就是程序是通过几个模块实现的。

各个模块之间互不影响的。

各个模块实现的算法可以不同,加减乘除和等号的输入比较简单在这就不描述了,下面对数字的输入和显示做简要的描述,如下图所示:0 1 0 1 2开始 初始化 第一位数加减乘除的输入 第二位数等号键的输入 Num =?显示结束数字的输入Num1=? 整数的输入 小数的输入数字的显示F=?显示第一位 数显示第二位 数显示结果四.算法数字的输入与显示1>.如何从键盘上读出键入的值并且如实的表示出来?例如按顺序输入12.12,则在数码管上显示12.12,我们可设一变量th,从键盘上所读出来的值key ,th=th*10+key,如果按顺序输入1 2 .1 2 ,则th的值为1212。

简易计算器设计实验报告

简易计算器设计实验报告

简易计算器设计实验报告一.设计任务及要求1.1实验任务:根据计算器的原理设计一个具有加减乘除功能的简易计算器。

如:5+3*4/8=4。

1.2 实验基本要求:(1)实现最大输入两位十进制数字的四则运算(加减乘除)。

(2)能够实现多次连算(无优先级,从左到右计算结果)。

如:12+34*56-78/90+9=36(3)最大长度以数码管最大个数为限,溢出报警。

二.实验设计方案(1)用QuartusII的原理图输入来完成系统的顶层设计。

(2)用VHDL编写以及直接拖模块来各功能模块。

(3)通过2个脉冲分别实现个位数和十位数的输入。

(4)通过选择每次的输出数值,将输出值反馈到运算输入端(4)通过除法运算实现十六进制到十进制的转换输出。

其具体实现流程图如下:三系统硬件设计FPGA:EP2C5T144C8目标板及相应外围硬件电路。

(从略)四系统软件设计1.数据输入模块原理:用VHDL创建模块,通过两个脉冲分别对两个数码管进行输入控制,再通过相应运算模块将两个独立数据转化成两位十进制数字。

2.运算模块原理:用VHDL创建模块,四种运算同步运行,通过按键加、减、乘、除选择输出对应的计算结果,当按键等号来时,将所得结果反馈给运算模块输入端。

具体实现代码见附录二。

3.输出模块原理:用VHDL创建模块,通过按键等号来控制显示运算对象还是运算结果,当等号按下时,输出计算结果,否则显示当前输入的数据,并且通过除法模块将十六进制转化为十进制。

当输出结果溢出是LED0亮,同时数码管显示都为零。

部分实现见附录二。

五实验调试输入数据12,再按加法键,输入第二个数字25,按等号键,数码管显示37;按灭加法、等号键,输入第二个数据2,依次按等号键,减法键,数码管显示35;同上,按灭减法键、等号键,输入第三个数据7,依次按等号键,除法键,数码管显示5;按灭除法键、等号键,输入第四个数据99,依次按等号键,乘法键,数码管显示495,按灭乘法键、等号键,当前显示为99,依次按等号键、乘法键,数码管显示49005,同上进行若干次之后,结果溢出,LED0亮,同时数码管显示都为零。

自己写的计算器(加减乘除)代码

自己写的计算器(加减乘除)代码

⾃⼰写的计算器(加减乘除)代码⾸先是Calculator计算器类package zydCalr;public class Calculator {public double addition(double number1, double number2) {return number1+number2;}public double subtraction(double number1, double number2) {return number1-number2;}public double multiplication(double number1, double number2) {return number1*number2;}public double divsition(double number1, double number2) {return number1/number2;}}接下来是Execute运⾏类package zydCalr;import java.util.Scanner;public class Execution {public double execute(String str){String expression = str + "+1";// 初始化开始//char[] Cexpression = expression.toCharArray();// 创建运算器Calculator calculator = new Calculator();// 数值列表double[] numbers = new double[30];int numbersindex = 0;// 转型列表char[] sub = new char[30];// 数值下标位置int count = 0;// 符号列表char[] symbols = new char[10];int symbolsindex = 0;// temp1是数值列表上⼀个数值,temp2是当前的数值double temp1 = 0, temp2 = 0;;// 符号char symbol = 0;int flag = 1;// 初始化结束// 第⼀次遍历for (int i = 0; i < expression.length(); i++) {if (Cexpression[i] >= '0' && sub[i] <= '9') {sub[count++] = Cexpression[i];} else {// 字符串转型doubletemp2 = transition(sub,count);// 当flag=2时进⾏运算if (flag == 2) {flag = 1;// 获取数值列表前⼀个数值;temp1 = numbers[numbersindex - 1];// 判断symbol乘法还是除法,成功是乘法,失败为除法if (decide(symbol)==1) {temp2 = calculator.multiplication(temp1, temp2);} else {temp2 = calculator.divsition(temp1, temp2);}// 覆盖前⼀个数值numbersindex--;}// temp2存⼊数值列表numbers[numbersindex++] = temp2;// 获取符号symbol = Cexpression[i];// 转型数值下标位置清零count = 0;// 判断是否⼤于flag,flag=2,不⼤于则加⼊到符号列表if (judge(symbol) > flag) {flag = 2;} else {// 加⼊到符号列表symbols[symbolsindex++] = symbol;}}}double temp = numbers[0];count = 0;for (int i = 1; i < numbers.length; i++) {if (symbols[count] == '+') {temp += numbers[i];count++;} else if (symbols[count] == '-') {temp -= numbers[i];count++;}}return temp;}private static int judge(char symbol) {if (symbol == '+') {return 1;} else if (symbol == '-') {return 1;} else if (symbol == '*') {return 2;} else if (symbol == '/') {return 2;}return 0;}private static int decide(char symbol) {if (symbol == '*') {return 1;} else if (symbol == '/') {return 2;}return 2;}private static int transition(char[] sub1,int count) {int temp = 0;for (int i = 0; i < count; i++) {if (sub1[i] >= '0' && sub1[i] <= '9') {temp = temp * 10;temp += (sub1[i] - '0');}}return temp;}}产⽣表达式类package zydCalr;import java.util.Random;public class ProductionExpression {//⽣成数值public static String producerNumber() {int number = (int) (Math.random() * 50);return String.valueOf(number);}//⽣成数值public static String producerOpreator() {int number = (int) (Math.random() * 4);String[] operator = { "+", "-", "*", "/" };return operator[number];}//产⽣public static String producer(int i) {StringBuilder sb = new StringBuilder();int flag = (int) (Math.random() * 5);if(flag==1){sb.append("-");}sb.append(producerNumber());while (i > 0) {sb.append(producerOpreator());sb.append(producerNumber());i--;}return sb.toString();}//产⽣表达式public static String producerExpression() {int lenght = (int) (Math.random() * 5);if (lenght % 2 == 0) {lenght++;}String expression = producer(lenght);return expression;}}⽣产者类package zydCalr;import java.util.ArrayList;import java.util.List;public class Producer implements Runnable {static final int MAXQUEUE = 5;private List<String> messages = new ArrayList<String>(); private ProductionExpression pe=new ProductionExpression(); @Overridepublic void run() {// TODO Auto-generated method stubwhile (true) {putMessage();try {Thread.sleep(1000);} catch (InterruptedException e) {e.printStackTrace();}}}private synchronized void putMessage() {while (messages.size() >= MAXQUEUE) {try {wait();} catch (InterruptedException e) {e.printStackTrace();}}//⽣成表达式messages.add(pe.producerExpression());notify();}public synchronized String getMessage() {while (messages.size() == 0) {try {notify();wait();} catch (InterruptedException e) {e.printStackTrace();}}String message = (String) messages.remove(0);notify();return message;}}消费者类package zydCalr;public class Consumer implements Runnable {Producer producer;Consumer(Producer producer) {this.producer = producer;}public void run() {while (true) {System.out.println("-------------开始⼀组表达式处理-------------");String message = producer.getMessage();System.out.println("⽣成表达式:" + message);Execution exe=new Execution();System.out.printf("处理结果:"+"%.2f\n",exe.execute(message));try {Thread.sleep(2000);} catch (InterruptedException e) {e.printStackTrace();}}}public static void main(String[] args) {Producer producer = new Producer();new Thread(producer).start();Consumer consumer = new Consumer(producer);new Thread(consumer).start();}}代码还是很简单的,主要有两个列表,⼀个列表存数值,⼀个列表存符号,如果符号是乘法或者除法,则把当前的数值和数值列表最后的数值相乘或相除,然后覆盖到数字列表的最后,如果不是,则存⼊数值列表的最后,符号列表添加当前的减法或者乘法,最后我发现许多细节的东西没有处理。

毕业设计简易加减乘除计算器

毕业设计简易加减乘除计算器

毕业设计题目简易加减乘除计算器系别专业班级姓名学号指导教师日期设计任务书设计题目:简易加减乘除计算器设计要求:1.根据所学内容运用编程做一个简易加减乘除计算器,实现加、减、乘、除、等以及清零的功能。

2.设置一组数码管, 使其能够显示程序运行,按键动作的内容。

3.设置一组按键,使其键依次对应0——9、“+”、“-”、“*”、“/”、“=”和清除键。

4.可以进行小于255的数的加减乘除运算,并可连续运算。

当键入值大于255时,将自动清零,可重新输入。

设计进度要求:第一周:确定题目,寻找单片机和计算器设计的相关资料;第二周:读懂资料,有初步的设计思路;第三周:绘制硬件电路图;第三周:设计软件框图;第四周:相应软件设计(程序设计);第五周:进行程序调试并且修改;第六周:写毕业设计论文;第七周:修改并提交毕业设计;第八周:准备论文答辩;指导教师(签名):摘要在很多领域的数据处理中要用到数学运算,作为计算机自动处理系统更显得重要。

此项目设计以单片机为核心部件的计算器,采用4*4矩阵式键盘,16个键依次对应0——9、“+”、“-”、“*”、“/”、“=”和清除键。

使用单片机最小应用系统1模块,简单方便。

采用静态显示,显示器由5个共阴极数码管组成。

输入只有两个信号,它们是串行数据线DIN和移位信号CLK。

5个串/并行移位寄存器芯片74LS164首尾相连。

每片的并行输出作为LED数码管的段码。

本计算器系统简单,实用性强,成本低,使用维护方便,软件功能强,运行稳定可靠等优点。

关键词:单片机,计算器,键盘,静态显示前言随着半导体集成工艺的不断发展,单片机的集成度将更高、体积将更小、功能将更强。

在单片机家族中,80C51系列是其中的佼佼者,加之Intel公司将其MCS –51系列中的80C51内核使用权以专利互换或出售形式转让给全世界许多著名IC制造厂商,如Philips、 NEC、Atmel、AMD、华邦等,这些公司都在保持与80C51单片机兼容的基础上改善了80C51的许多特性。

简易计算器说明书

简易计算器说明书
(6)电源开关
(7)其他基本函数,例如求平方根或百分比键 (%)
更高级的模块也许会有一个单数值记忆按键(M+,M-),可在需要时叫回。
高级电子计算器
较高级的科学计算器或工程型计算器支持三角函数、统计与其他函数。而最先进的现代计算器甚至可显示图型,并且包含计算机代数系统。这种计算器可以编写程序,且内含了代数方程式求解程序、经济模型甚至游戏程序。这类计算器可显示填满显示屏的单一数值。并可将数字以科学记数法表现至9.999999999*10。如果用户试图输入一过大的数值或运算产生过大数值的算式(例如输入100!,即100阶乘),则计算器仅显示错误一词。因为存储器如此有限的计算器无法存储如此巨大的输入(>=10^160)。
1)在程序之中加入足够的操作提醒环节,使得使用者能够清楚的掌握操作流程和界面。
2)程序中分类完成+、-、*、/、x^y、求余、x为底y的对数、求平均,sin、cos、tan、exp、ln、以10为底的对数、取整、平方、立方、绝对值,进制之间的转换;使用者可以根据个人的需要在提示后输入相应的代码,然后进行相应的运算,最后在运算结果中查找自己需要的即可;如需做多步骤运算,只要在上一次运算结束后按照提示输入相应代码即可选择是继续进行运算还是退出程序,操作简便。
3.2算法说明10
4调试分析14
4.1调试目的14
4.2测试要求14
4.3测试方法14
4.4调试与测试结果17
5总结19
参考文献21
致谢22
附录23
1概述
通过本项课程设计,可以培养独立思考、 综合运用所学有关相应知识的能力,能更好的巩固《C语言程序设计》课程学习的内容,掌握 工程软件设计的基本方法,强化上机动手编程能力,闯过理论与实践相结合的难关!更加了解了c语言的好处和其可用性!同时增加了同学之间的团队合作精神!更加也体会到以后在工作中团队合作的重要性和必要性!通过C语言课程设计,使自己了解高级程序设计语言的结构,掌握基本的程序设计过程和技巧,掌握基本的分析问题和利用计算机求解问题的能力,具备初步的高级语言程序设计能力。为后续各门计算机课程的学习和毕业设计打下坚实基础。

简易计算器代码

简易计算器代码
<td>
<input type="button" value="-" name="b6" onClick="SetExp('-')">
</td>
<td>
<input type="button" value="*" name="b5" onClick="SetExp('*')">
</td>
</tr>
<tr align="center">
</td>
<td>
<input type="button" value="3" name="b3" onClick="SetExp('3')">
</td>
</tr>
<tr align="center">
<td>
<input type="button" value="4" onClick="SetExp('4')">
<td>
<input type="button" value="7" onClick="SetExp('7')">
</td>
<td>

微型计算机课程设计-简易计算器

微型计算机课程设计-简易计算器

课程设计设计名称: 微型计算机技术及应用——简易计算器学院:信息工程学院课程:微型计算机技术及应用姓名:学号:班级:2014级计算机科学与技术二班目录摘要 (3)一、前言 (4)1.1背景 (4)1.2项目介绍 (4)二、课程设计的目的与任务 (5)2.1设计目的 (5)2.2设计任务 (5)三、设计过程 (5)3.1基础理论 (5)3.1.1DOSBox简介 (5)3.1.2中断 (8)四、设计 (11)4.1总体方案 (11)4.2原理框图 (12)4.3程序代码 (13)五、系统模块详细设计与调试 (24)5.1系统模块详细设计 (24)5.1.1设置屏幕显示方式 (24)5.1.2显示主菜单 (24)5.1.3从键盘接收一个数字 (24)5.1.4接收键入用于计算的数 (25)5.1.5显示结果 (25)5.1.6子程序A2——将数的ASCII码转为二进制数 (25)5.1.7将计算结果的二进制数转换为对应的十进制数ASCII码并输出显示(A3程序段) (27)5.2程序编译、运行与调试 (27)六、设计总结 (29)七、参考文献 (31)摘要本次课程设计是通过使用DOSBox汇编语言编程软件实现的利用汇编语言编写的较为复杂的程序设计。

该课程设计主要是设计一个较为简单的计算器,界面显示要求用户从键盘上分别输入两个随机数,完成四则运算,然后将运算结果显示到屏幕上。

该设计智能实现简单的正整数之间的四则运算,无法对小数进行精确地识别。

而除法运算可以精确到3位小数,减法可以显示出负数的结果。

采用DOS调用(INT 21H)来完成键盘的输入和屏幕的输出。

通过这次的课程设计能够进一步加深对专业知识和理论知识学习的认识和理解。

关键词:DOSBox;微机原理;计算器;汇编语言一、前言1.1背景计算器是现代人发明的可以进行数字运算的电子机器。

现代的电子计算器能进行数学运算的手持电子机器,拥有集成电路芯片,但结构比电脑简单得多,可以说是第一代的电子计算机(电脑),且功能也较弱。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

此计算机包含+,-,/,*,!,sin,tan,cos,^,e。

#include<iostream.h>#include<math.h>#include <iomanip.h>#include<stdlib.h>#define max 100#define MaxOp 100struct //设定运算符优先级{char ch; //运算符int pri; //优先级}lpri[]={{'=',0},{'(',1},{'*',5},{'/',5},{'+',3},{'-',3},{')',6},{'^', 7},{'e',7},{'!',7},{'s',7},{'t',7},{'c',7}},rpri[]={{'=',0},{'(',6},{'*',4},{'/',4},{'+',2},{'-',2},{')',1},{'^', 6},{'e',6},{'!',6},{'s',6},{'t',6},{'c',6}};int leftpri(char op) //求左运算符op的优先级{int i;for(i=0;i<MaxOp;i++)if(lpri[i].ch==op)return lpri[i].pri;}int rightpri(char op) //求右运算符op的优先级{int i;for(i=0;i<MaxOp;i++)if(rpri[i].ch==op)return rpri[i].pri;}int InOp(char ch) //判断ch是否运算符{if(ch=='('||ch==')'||ch=='+'||ch=='-'||ch=='*'||ch=='/'||ch=='^'| |ch=='e'||ch=='!'||ch=='t'||ch=='s'||ch=='c')return 1;elsereturn 0;}int precede(char op1,char op2) //op1和op2运算符的比较结果{if(leftpri(op1)==rightpri(op2))return 0;else if(leftpri(op1)<rightpri(op2))return -1;elsereturn 1;}void trans(char*exp,char postexp[]) //将算术表达式exp转换为后缀表达式postexp{struct{char data[max]; //存放运算符int top; //栈指针}op; //定义运算符栈int i=0; //i作为postexp的下标op.top=-1;op.top++;op.data[op.top]='='; //将“=”进栈char *t;cout<<"-----------------------------------------------------------------"<<endl;cout<<"当前符号输入区 op栈输出区"<<endl;cout<<"-----------------------------------------------------------------"<<endl;while(*exp!='\0') //*exp未扫描完时循环{if(!InOp(*exp)) //为数字字符情况下{t=exp;while(*exp>='0'&&*exp<='9'||*exp=='.') //判定为数字{cout<<*exp; //输出中缀表达式的头指针postexp[i++]=*exp;exp++;}cout<<"\t";cout.setf(ios::left);cout<<setw(20);cout<<t;for(int n=1;n<=op.top;n++)cout<<op.data[n];cout<<"\t\t ";for(n=0;n<i;n++){cout<<postexp[n];if(!(postexp[n]>='0'&&postexp[n]<='9')&&postexp[n]!=' ')cout<<' ';}cout<<endl;postexp[i++]=' '; //用' '标识一个数值串结束}else{int n;switch(precede(op.data[op.top],*exp)){case -1: //为运算符情况下t=exp;op.top++;op.data[op.top]=*exp;cout<<*exp;if(*exp=='s')cout<<"in";if(*exp=='c')cout<<"os";if(*exp=='t')cout<<"an";cout<<"\t";exp++;cout.setf(ios::left);cout<<setw(20);cout<<t;for(n=1;n<=op.top;n++)cout<<op.data[n];cout<<"\t\t ";for(n=0;n<i;n++){cout<<postexp[n];if(!(postexp[n]>='0'&&postexp[n]<='9')&&postexp[n]!=' ')cout<<' ';}cout<<' ';cout<<endl;break;case 0: //只有括号满足这一情况op.top--; //此时将退栈cout<<*exp;if(*exp=='s')cout<<"in";if(*exp=='c')cout<<"os";if(*exp=='t')cout<<"an";cout<<"\t";exp++;cout.setf(ios::left);cout<<setw(20);cout<<t;for(n=1;n<=op.top;n++)cout<<op.data[n];cout<<"\t\t ";for(n=0;n<i;n++){cout<<postexp[n];if(!(postexp[n]>='0'&&postexp[n]<='9')&&postexp[n]!=' ')cout<<' ';}cout<<endl;break;case 1: //栈顶运算符优先级高于当前运算符postexp[i++]=op.data[op.top];op.top--;break;}}}while(op.data[op.top]!='=') //此时exp扫描完毕,退栈到'='为止{postexp[i++]=op.data[op.top];op.top--;}postexp[i]='\0'; //给postexp表达式添加结束标识cout<<"\t\t\t\t\t\t";for(int p=0;postexp[p]!='\0';p++){cout<<postexp[p];if(!(postexp[p]>='0'&&postexp[p]<='9')&&postexp[p]!=' ') cout<<' ';}cout<<endl;}/////////////////////////////////////////////////////////////////////int check(char *exp){int i=0,flag=1;while(exp[i]!='\0') //判断运算符号是否表达正确{if(exp[i]>='0' && exp[i]<='9' || exp[i]=='.' || exp[i]=='-' || exp[i]=='+' || exp[i]=='*' || exp[i]=='(' || exp[i]==')'|| exp[i]=='/' || exp[i]=='^' ||exp[i]=='!'|| exp[i]=='d' || exp[i]=='s' || exp[i]=='c' || exp[i]=='t' || exp[i]=='e');else flag=0;if(exp[0]=='+'||exp[0]=='-'||exp[0]=='*'||exp[0]=='/'||exp[0]=='^ '||exp[0]=='.'||exp[0]=='!') //表达式第一项不出现加减乘除flag=0;if(i!=0&&(exp[i]=='s' || exp[i]=='c' || exp[i]=='t' || exp[i]=='e')&&(exp[i-1]>='0' && exp[i-1]<='9' || exp[i-1]=='.'))flag=0;if((exp[i]=='+'||exp[i]=='-'||exp[i]=='*'||exp[i]=='/'||exp[i]==' ^'||exp[i]=='!')&& //'+'、'-'、'*'、'/'、'^'等运算符号后面必须接一个数值或其他!(exp[i+1]>='0' && exp[i+1]<='9'|| exp[i+1]=='e' || exp[i+1]=='s'|| exp[i+1]=='c' || exp[i+1]=='t' || exp[i+1]=='('))flag=0;i++;}return flag;}///////////////////////////////////////////////////////////////////// ///////double compvalue(char *postexp) //计算后缀表达式的值{struct{double data[max]; //存放数值int top; //栈指针}st; //定义数值栈int k;double d1=0,d,a,b,c;st.top=-1;while(*postexp!='\0') //postexp字符串未扫描完时循环{switch(*postexp){case'+': //判定为'+'号a=st.data[st.top];st.top--; //退栈取数值ab=st.data[st.top];st.top--; //退栈取数值bc=a+b; //计算cst.top++;st.data[st.top]=c; //将计算结果进栈break;case'-': //判定为'-'号a=st.data[st.top];st.top--; //退栈取数值ab=st.data[st.top];st.top--; //退栈取数值bc=b-a; //计算cst.top++;st.data[st.top]=c; //将计算结果进栈break;case'*': //判定为'*'号a=st.data[st.top];st.top--; //退栈取数值ab=st.data[st.top];st.top--; //退栈取数值bc=a*b; //计算cst.top++;st.data[st.top]=c; //将计算结果进栈break;case'/': //判定为'/'号a=st.data[st.top];st.top--; //退栈取数值ab=st.data[st.top];st.top--; //退栈取数值bif(a!=0){c=b/a; //计算cst.top++;st.data[st.top]=c; //将计算结果进栈}else{cout<<"\n\t除零错误\n";exit(0);//异常退出}break;case'^': //判定为'^'号int i;a=st.data[st.top];st.top--; //退栈取数值ab=st.data[st.top];st.top--; //退栈取数值bc=1; //计算cfor(i=0;i<a;i++)c*=b;st.top++;st.data[st.top]=c; //将计算结果进栈break;case'e': //判定为'exp'号a=st.data[st.top];st.top--; //退栈取数值ac=exp(a); //计算cst.top++;st.data[st.top]=c; //将计算结果进栈break;case'!': //判定为'^'号a=st.data[st.top];st.top--; //退栈取数值a c=1; //计算cfor(i=1;i<a+1;i++)c=c*i;st.top++;st.data[st.top]=c; //将计算结果进栈break;case 't':a=st.data[st.top];st.top--;c=tan(a);st.top++;st.data[st.top]=c;break;case 's':a=st.data[st.top];st.top--;c=sin(a);st.top++;st.data[st.top]=c;break;case 'c':a=st.data[st.top];st.top--;c=cos(a);st.top++;st.data[st.top]=c;break;default://处理数字字符d=0;while(*postexp>='0'&&*postexp<='9'||*postexp=='.') //判定为数字字符{if(*postexp>='0'&&*postexp<='9'){d=10*d+*postexp-'0';//将连续的数字字符转换成对应的数值存放到d中postexp++;}else{*postexp++;i=0;while(*postexp>='0'&&*postexp<='9'){d1=10*d1+*postexp-'0';*postexp++;i++;}for(k=0;k<i;k++)d1=d1/10;}}d=d+d1;d1=0;st.top++;st.data[st.top]=d;break;}postexp++; //继续处理其他字符}return(st.data[st.top]);}int check2(char *postexp) ///判断是否括号对称{while(*postexp!='\0'){if(*postexp=='('||*postexp==')')return 1;*postexp++;}return 0;}void main(){cout<<"----------------------------------------------"<<endl;cout<<"本计算器包含的运算符有:"<<endl;cout<<"+ - * /"<<endl;cout<<"^ !"<<endl;cout<<"sin() cos() tan() exp()"<<endl;cout<<"(s表示sin,c表示cos,t表示tan,e表示exp)\n"<<endl;cout<<" By WeizhongYoung"<<endl;cout<<"------------------------------------------------"<<endl;char h='y';while(h=='y'||h=='Y') //当st=='y'/'Y'时循环{char exp[max],postexp[max];cout<<"请输入表达式:";cin>>exp;cout<<endl;if(!check(exp)&&!check2(postexp)) //判断是否输入错误{cout<<"输入有误,请重新输入!"<<endl;continue;}else{cout<<"输出中缀表达式:"<<exp<<endl;trans(exp,postexp);cout<<"输出n逆波兰表达式:";for(int p=0;postexp[p]!='\0';p++){cout<<postexp[p];if(!(postexp[p]>='0'&&postexp[p]<='9')&&postexp[p]!=' ')cout<<' ';}cout<<endl;cout<<"输出表达式的值为:"<<compvalue(postexp)<<endl;}cout<<"是否继续运行(Y,N),输入Y/y继续,输入n/N退出: "; //用户输入是否要继续使用计算器cin>>h;cout<<endl;}exit(0);}。

相关文档
最新文档