汇编大作业(四则运算器含代码)
Python编程基础与应用 简单四则运算计算器[3页]
![Python编程基础与应用 简单四则运算计算器[3页]](https://img.taocdn.com/s3/m/2dc6decd988fcc22bcd126fff705cc1754275f5a.png)
简单四则运算计算器【案例描述】使用面向对象编程思想，编写一个简单的四则运算器。
可以通过数值的输入，进行整数四则运算，并且能够反复运算，直至输入退出信息为止。
【案例分析】1）按要求设计一个计算器类，包含四个运算方法。
2）为了使程序可以反复运算，直到选择退出为止，可以使用while循环语句实现。
3）开始运行时，需要用户输入两个需要计算的数，和输入需要运算的法则。
4）创建一个计算器对象，根据运算的法则调用对象中相应的方法，完成计算任务。
它用到的技术点有以下几方面：定义计算器类，定义类的方法和属性。
通过选择判断结构选择对象对应的方法执行运算。
【实施步骤】新建Python文件“computer.py”，输入以下代码。
class Computer:one=0two=0op=''result=0#构造函数def __init__(self,sone,stwo):self.one=soneself.two=stwo#定义加法def addone(self):result=one+tworeturn result#定义减法def minus(self):result = one - tworeturn result#定义乘法def multiply(self):result = one * tworeturn result#定义除法def division(self):result = one / tworeturn result#实例化类，调用它进行计算print("本程序是一个简易的四则运算计数器.")flag = Truewhile flag:one = int(input("请输入第一个数："))two = int(input("请输入第二个数："))operation = input("请输入要执行的四则运算(+-*/)：")cp=Computer(one,two)if operation == '+':print(cp.addone())elif operation == '-':print(cp.minus())elif operation == '*' or operation == 'x':print(cp.multiply())elif operation == '/' or operation == '÷':print(cp.division())else:print("输入有误！")while True:Continue = input("是否继续?y/n：")if Continue == 'y':breakelif Continue == 'n':while_condition = Falsebreakelse:print("输入有误，请重新输入！")【调试结果】可以直接在文件夹路径中双击“computer.py”文件，即可调用，输入需要运算的两个数以及运算符号后，程序会自动进行计算，效果如图1所示。
四则运算（c++）
四则运算（c++）软件⼯程导论作业要求作业⽬标编写⼀个能够⾃动⽣成四则运算题⽬的程序学号31907042091 #include<iostream>2 #include<string>3 #include<stdlib.h>4 #include<time.h>5 using namespace std;6 int suiji2(int min,int max)7 {8 int b=-1;9 b=rand();10 if(b>max||b<min)11 {12 b%=max;//保证b<9913 b+=max;//防⽌余数为负14 b%=max;15 b+=1;//使得到的数在1~99之间16 }17 return b;18 }19 void main()20 {2122 int a[100],b=5,c=1;23 string str="+-/*";24 while(1) //总循环可以⽆限⽣成题⽬25 {26 c=1;27 //输⼊⽣成题⽬的条件28 cout<<"⼀共出⼏道题：";29 cin>>b;30 cout<<"是否有乘除法（1，0）：";31 cin>>a[98];32 if(a[98]==0)33 {34 str="+-+-";35 }36 cout<<"最多⼏个数(10个数之间)：";37 cin>>a[97];38 cout<<"数值范围：\n最⼤值：";39 cin>>a[96];40 cout<<"最⼩值：";41 cin>>a[95];42 cout<<"加减有⽆负数（1或0）(如果输⼊1则默认俩则加减运算)：";43 cin>>a[94];44 if(a[98]==1)//如果前⾯输⼊了不包括乘除法则此条件⽆意义45 {46 cout<<"乘除有⽆余数（1或0）(如果输⼊1则默认俩则乘除运算)：";47 cin>>a[93];48 }49 //结束输⼊⽣成题⽬的条件50 while(b--) //循环⼀次⽣成⼀道题51 {52 int num=suiji2(3,a[97]);cout<<endl;53 int i=0,j=0;54 while(i<=num*3) // 初始化数组55 {56 a[i]=suiji2(a[95],a[96]);57 i++;58 }59 while(j<=num*3)60 {61 a[j]%=4;//运算符62 a[j+1]%=2;//括号63 if(a[j+1]==1)64 {65 a[j+4]=-1;66 }67 j+=3;68 }69 cout<<"";70 if(a[94]==1||a[93]==1)71 {72 num=2;73 }7475 cout<<"No."<<c++<<":"; //题⽬计数器76 if(num==2) //2则运算77 {7879 if(a[94]==1&&a[3]==1)80 {81 if(a[2]<a[5])82 {83 cout<<a[5]<<str[a[3]]<<a[2];84 }85 else86 cout<<a[2]<<str[a[3]]<<a[5];87 }88 else if(a[3]==2&&a[93]==1)89 {90 if(a[2]%a[5]!=0)91 {92 cout<<a[2]-(a[2]%a[5])<<str[a[3]]<<a[5];93 }94 else95 cout<<a[2]<<str[a[3]]<<a[5];96 }97 else cout<<a[2]<<str[a[3]]<<a[5];9899 }100 else //多则运算101 {102 j=1;103 while(j<=num*3)104 {105106 if(a[j]==1&&j<num*3-3&&a[j+2]!=2&&a[j+2]!=3)cout<<"(";107 cout<<a[j+1];108 if(a[j-3]==1&&j>3&&a[j-1]!=2&&a[j-1]!=3)cout<<")";109 if(j<(num*3-3))cout<<str[a[j+2]];110 j+=3;111 }112 }113 cout<<"="<<endl;114 }115 }116 }<head> <meta http-equiv=Content-Type content="text/html; charset=gb2312"> <meta name=ProgId content=Excel.Sheet> <meta name=Generator content="Microsoft Excel 15"> <link id=Main-File rel=Main-File href="../⼯作簿1.htm"> <link rel=File-List href=filelist.xml> <link rel=Stylesheethref=stylesheet.css> <style> <!--table {mso-displayed-decimal-separator:"\."; mso-displayed-thousand-separator:"\,";} @page {margin:.75in .7in .75in .7in; mso-header-margin:.3in; mso-footer-margin:.3in;} ruby {ruby-align:left;} rt {color:windowtext; font-size:9.0pt; font-weight:400; font-style:normal; text-decoration:none; font-family:等线; mso-generic-font-family:auto; mso-font-charset:134; mso-char-type:none; display:none;} --> </style> <![if!supportTabStrip]><script language="JavaScript"> <!-- function fnUpdateTabs() { if (parent.window.g_iIEVer>=4) { if(parent.document.readyState=="complete" && parent.frames['frTabs'].document.readyState=="complete") parent.fnSetActiveSheet(0); else window.setTimeout("fnUpdateTabs();",150); } }if (!="frSheet")window.location.replace("../⼯作簿1.htm");elsefnUpdateTabs();//--><![endif]></head>psp任务内容计划完成需要的时间（h)实际完成需要的时间（h) Planning计划0.20.2Estimate估计这个任务需要多少时间，并规划⼤致⼯作步骤0.20.2Development开发3034Analysis需求分析（包括学习新技术）35Design Spec⽣成设计⽂档0.20.3Design Review设计复审0.20.4Coding Standard代码规范0.20.3Design具体设计54Coding 具体编码109Code Review代码复审2 1.8Test测试（⾃我测试，修改代码，提交修改）0.20.3Reporting报告2 1.2Test Report测试报告0.20.2Size Measurement计算⼯作量0.20.3Postmortem&Process ImprovementPlan事后总结，并提出过程改进计划0.20.1</body>经过本次设计后发现⾃⼰对于这些所学到的知识依旧不能够灵活使⽤，但同时也学到了很多，⽐如psp表格的插⼊可以通过转换为html后通过引⼊源代码来插⼊，图⽚的插⼊也可以多样，⽹址插⼊或者是本地导⼊等等。
四则运算器代码
四则运算器代码简单的四则运算器可以执行加、减、乘、除四种基本运算。
使用python和C++编写实例：（一）使用python编写：# 定义函数实现加法def add(x, y):return x + y# 定义函数实现减法def subtract(x, y):return x - y# 定义函数实现乘法def multiply(x, y):return x * y# 定义函数实现除法def divide(x, y):if y == 0:raise ValueError('除数不能为0')return x / y# 主程序，输入两个数和运算符，输出运算结果或错误信息while True:try:num1 = float(input('请输入第一个数：'))num2 = float(input('请输入第二个数：'))op = input('请输入运算符（+、-、*、/）：')if op == '+':result = add(num1, num2)elif op == '-':result = subtract(num1, num2)elif op == '*':result = multiply(num1, num2)elif op == '/':result = divide(num1, num2)else:print('无效的运算符')continueprint('运算结果：', result)except ValueError as e:print('输入错误：', e)except Exception as e:print('程序错误：', e)在上面的代码中，我们定义了四个函数分别实现加、减、乘、除四种基本运算。
四则运算的实现
四则运算的实现在数学运算中，四则运算是最基本也是最常见的运算之一。
它包括加法、减法、乘法和除法四种运算方式。
在计算机科学领域，实现四则运算是编程语言中一个非常基础和核心的功能。
本文将介绍四则运算的实现原理及其在计算机编程中的应用。
一、加法运算的实现加法运算是最简单的运算之一，通常用符号“+”表示。
在编程中，实现两个数的加法运算可以通过以下步骤：1. 输入两个待加数。
2. 将两个数相加得到和。
3. 输出和作为运算结果。
以下是一个示例代码，演示了如何实现加法运算：```pythona = int(input("请输入第一个数："))b = int(input("请输入第二个数："))sum = a + bprint("两数之和为：", sum)```二、减法运算的实现减法运算是在两个数之间进行相减的操作，通常用符号“-”表示。
在编程中，实现两个数的减法运算可以通过以下步骤：1. 输入被减数和减数。
2. 将被减数减去减数得到差。
3. 输出差作为运算结果。
以下是一个示例代码，演示了如何实现减法运算：```pythona = int(input("请输入被减数："))b = int(input("请输入减数："))difference = a - bprint("两数之差为：", difference)```三、乘法运算的实现乘法运算是将两个数相乘的操作，通常用符号“×”表示。
在编程中，实现两个数的乘法运算可以通过以下步骤：1. 输入两个待乘数。
2. 将两个数相乘得到积。
3. 输出积作为运算结果。
以下是一个示例代码，演示了如何实现乘法运算：```pythona = int(input("请输入第一个数："))b = int(input("请输入第二个数："))product = a * bprint("两数之积为：", product)```四、除法运算的实现除法运算是将被除数除以除数的操作，通常用符号“÷”表示。
微机设计报告(四则运算器)
学院：班级：姓名：学号：课程设计题目：四则运算计算器课程名称：汇编语言与微机原理评阅成绩：评阅意见：成绩评定教师签名：日期：年月目录概述 (1)一、设计要求 (1)二、设计思想 (1)三、程序工作原理 (2)四、程序流程图及说明 (3)五、程序源代码 (7)六、程序运行示例 (18)七、设计过程中遇到的问题及解决方法 (18)八、设计心得 (19)九、参考文献 (19)四则运算计算器概述此计算器，可以实现从键盘输入一个十进制的四则运算表达式，如:-3+4*（5-6）-8/2，编程计算表达式的值，输出十进制结果。
表达式和结果可以是三位或四位十进制，也可以是带负数的十进制数，并且＋－*/（）位置任意摆放（只要符合数学上的运算逻辑）。
一、设计要求用汇编语言设计一个程序，用来实现计算器的四则运算功能。
需要实现在屏幕要显示输入的表达式，以及运算结果。
例如：-3+4*（5-6）-8/2计算表达式的结果，并将该表达式及结果显示出来；设计要求如下：（1）由键盘作为输入部分。
（2）能进行四则混合运算，并且能计算带括号和负数的数学表达式。
（3）按ESC 键则退出计算器菜单界面并返回dos 系统，否则继续输入表达式，求得对应的结果。
二、设计思想根据题目的要求，可以把整个源程序大致划分六大步骤。
（1）首先键盘输入合法中缀算术表达式，并将其存储到S1中。
（2）然后调用子程序CHANGE将中缀式转化为后缀式。
（3）调用子程序CALCULATE对后缀表达式进行有符号数的运算，并将最终结果存放在栈中。
（4）POP AX，AX->STORAGE，即用STORAGE 存放最终运算结果。
（5）调用子程序OUTPUT将运算结果输出。
（6）通过用键盘输入ESC退出DOS程序。
三、程序工作原理步骤一的原理：此处用系统功能1号调用，每次从键盘输入一个字符，就将其存入到数组S1中，然后在判断此字符是否为回车，如果不是，则循环，继续输入字符，否则，程序往下执行。
汇编语言课程设计四则运算计算器
*******************实践教学*******************兰州理工大学技术工程学院2013年春季学期汇编语言实训课程设计题目：四则运算计算器专业班级：计算机科学与技术姓名：___郭利强_____学号： 11730108指导教师：刘树群成绩：计算机科学与技术专业(11级)汇编语言实训课程设计任务书题目：四则运算计算器班级： 11计算机科学与技术1班学生姓名：郭利强学号： 11730108 题目类型：软件工程（R）指导教师：刘树群一．题目简介四则运算计算器，主要是为了解决数学中的加、减、乘、除四则运算的问题。
通过该题目的设计过程，可以培养学生结构化程序设计的思想，加深对汇编语言基本语言要素和流程结构的理解，针对汇编语言中的重点和难点内容进行训练，独立完成有一定工作量的程序设计任务，同时强调好的程序设计风格。
得到软件工程的综合训练，提高解决实际问题的能力。
二．设计任务1、查阅文献资料，一般在5篇以上；2、要求可以进行四则运算；3、完成软件结构设计和算法设计；4、完成系统的软件开发和测试工作；5、撰写设计说明书；6、做好答辩工作。
三．主要内容、功能及技术指标1、实现功能及指标：①使用Win32的窗口程序模式，实现四则运算程序的设计与开发；②界面友好。
2、问题分析及解决方案框架确定：充分地分析和理解问题本身，弄清要求做什么。
在确定解决方案框架过程中，综合考虑系统功能，考虑怎样使系统结构清晰、合理、简单和易于调试。
最后确定每个过程和函数的简单功能，以及过程（或函数）之间的调用关系，并画出函数之间的调用关系图。
3、详细设计和编码：定义相应的存储结构，确定各个函数的算法，并画出流程图，在此基础上进行代码设计，每个明确的功能模块程序一般不超过200行，否则要进一步划分。
4、上机前程序静态检查：上机前程序静态检查可有效提高调试效率，减少上机调试程序时的无谓错误。
静态检查主要有两种途径：用一组测试数据手工执行程序；通过阅读或给别人讲解自己的程序而深入全面地理解程序逻辑。
c语言小学生四则运算练习题
c语言小学生四则运算练习题### C语言小学生四则运算练习题随着计算机编程教育的普及，越来越多的小学生开始接触编程。
C语言作为一门基础的编程语言，非常适合初学者学习。
四则运算是数学中的基本运算，通过编写C语言程序来实现四则运算，不仅可以锻炼小学生的逻辑思维，还能加深他们对编程语言的理解。
#### 题目一：加法运算编写一个C语言程序，实现两个整数的加法运算。
要求用户输入两个整数，程序输出它们的和。
```c#include <stdio.h>int main() {int num1, num2, sum;printf("请输入两个整数：");scanf("%d %d", &num1, &num2);sum = num1 + num2;printf("它们的和是：%d\n", sum);return 0;}```#### 题目二：减法运算编写一个C语言程序，实现两个整数的减法运算。
要求用户输入两个整数，程序输出它们的差。
```c#include <stdio.h>int main() {int num1, num2, difference;printf("请输入两个整数：");scanf("%d %d", &num1, &num2);difference = num1 - num2;printf("它们的差是：%d\n", difference);return 0;}```#### 题目三：乘法运算编写一个C语言程序，实现两个整数的乘法运算。
要求用户输入两个整数，程序输出它们的积。
```c#include <stdio.h>int main() {int num1, num2, product;printf("请输入两个整数：");scanf("%d %d", &num1, &num2);product = num1 * num2;printf("它们的积是：%d\n", product);return 0;}```#### 题目四：除法运算编写一个C语言程序，实现两个整数的除法运算。
高精度四则运算(万进制)C++
压位高精（万进制）//头文件：thp.h#ifndef _cstring_#define _cstring_#include <cstring>#endif#ifndef _cstdlib_#define _cstdlib_#include <cstdlib>#endifconst int THP_MAXLEN=1000;const int THP_MAXSTRLEN=4040;const int L0=10000;class thp{friend const thp operator-(const thp&,const thp&);friend const thp operator+(const thp&,const thp&);friend const thp operator*(const thp&,const thp&);friend const thp operator/(const thp&,const thp&);friend void thpdiv(const thp&,const thp&,thp&,thp&);friend const thp operator%(const thp&,const thp&);public:const thp& operator=(const thp&);const thp& operator=(const char*);bool operator==(const thp&)const;bool operator>=(const thp&)const;bool operator<=(const thp&)const;inline bool operator!=(const thp&)const;bool operator>(const thp&)const;bool operator<(const thp&)const;inline void shl(const int);const thp& operator ++ ();inline void makeempty();const char *tostr()const;inline thp& operator-=(const thp&);thp();thp(const char*);const int thpstd();protected:int _data[THP_MAXLEN],_high,_sign;private:};// 源代码 thp.cpp#include "thp.h"const int thp::thpstd(){ int i;for(i=0;i<=_high;i++){ while(_data[i]<0){ _data[i]+=L0;_data[i+1]--;}}return(0);}const thp operator % (const thp &a,const thp &b) { thp re1,re2;thpdiv(a,b,re1,re2);return(re2);}const thp& thp::operator ++ (){ _data[0]++;if(_data[0]>=L0)this->thpstd();return(*this);}void thp::shl(const int n){ int i;for(i=_high;i>=0;i--){ _data[i+n]=_data[i];}_high+=n;if(_data[_high]==0)_high=0;}thp& thp::operator -= (const thp &o){ int tint,i,len;for(i=0;i<=_high;i++){ tint=_data[i]-o._data[i];if(tint<0){ tint+=L0;_data[i+1]--;}_data[i]=tint;}for(len=this->_high;len>=0;len--){ if(_data[len]!=0)break;if(len==0)break;}_high=len;return(*this);}void thpdiv(const thp &a,const thp &b,thp &c,thp &d) { int i;d.makeempty();c.makeempty();for(i=a._high;i>=0;i--){ d.shl(1);d._data[0]=a._data[i];while(b<=d){ d-=b;c._data[i]++;}if(i==0)break;}c._high=0;for(i=a._high;i>0;i--){ if(c._data[i]!=0){ c._high=i;break;}}}inline bool thp::operator != (const thp &o)const{ return(!(0==memcmp(this,&o,sizeof(thp))));}bool thp::operator == (const thp &o)const{ return(0==memcmp(this,&o,sizeof(thp)));}inline bool thp::operator < (const thp &o)const{ int i;if(*this==o)return(false);{ if(this->_high!=o._high)return(this->_high<o._high);for(i=this->_high;i>=0;i--){ if(this->_data[i]!=o._data[i])return(this->_data[i]<o._data[i]);if(i==0)break;}}return(false);}bool thp::operator > (const thp &o)const{ if(*this==o)return(false);return(!(*this<o));}bool thp::operator <= (const thp &o)const{ return(*this<o||*this==o);}bool thp::operator >= (const thp &o)const{ return(!(*this<o));}inline int max(int a,int b){ return(a>b?a:b);}thp::thp(){ makeempty();}thp::thp(const char *s){ *this=s;}const thp operator-(const thp &a,const thp &b){ int i,len,tint;thp re;len=max(a._high,b._high);for(i=0;i<=len;i++){ tint=a._data[i]-b._data[i]+re._data[i];if(tint<0){ tint+=L0;re._data[i+1]--;}re._data[i]=tint;}while(len>0&&re._data[len]<1)len--;re._high=len;return(re);}const thp operator/(const thp &a,const thp &b){ thp re1,re2;thpdiv(a,b,re1,re2);return(re1);}const thp operator*(const thp &a,const thp &b){ int i,j,tint,len;thp re;for(i=0;i<=a._high;i++)for(j=0;j<=b._high;j++){ tint=a._data[i]*b._data[j]+re._data[i+j];re._data[i+j]=tint%L0;re._data[i+j+1]+=tint/L0;}len=i+j;if(re._data[len+1]!=0)len++;re._high=len;return(re);}const thp operator+(const thp &a,const thp &b){ int i,len,tint;thp re;len=max(a._high,b._high);for(i=0;i<=len;i++){ tint=a._data[i]+b._data[i]+re._data[i];re._data[i]=tint%L0;re._data[i+1]=tint/L0;}if(re._data[len+1]!=0)len++;re._high=len;return(re);}const char *thp::tostr()const{ char *re;char ts[5];int i,j,tint;re=(char *)malloc(THP_MAXSTRLEN);memset(ts,0,sizeof(ts));memset(re,0,THP_MAXSTRLEN);for(i=_high;i>=0;i--){ tint=_data[i];for(j=0;j<4;j++){ ts[3-j]=tint%10+'0';tint/=10;}strcat(re,ts);}while(strlen(re)>1&&*re=='0')re++;return(re);}inline void thp::makeempty(){ memset(this,0,sizeof(thp));}const thp& thp::operator = (const char *s) { char ts[5];memset(ts,0,sizeof(ts));int len,i;makeempty();len=strlen(s);_high=(len-1)/4;i=(len-1)%4+1;strncpy(ts,s,i);s+=i;_data[_high]=atoi(ts);i=_high;while(i>0){ i--;memset(ts,0,sizeof(ts));strncpy(ts,s,4);s+=4;_data[i]=atoi(ts);}return(*this);}const thp& thp::operator = (const thp &hp) { memcpy(this,&hp,sizeof(thp));return(*this);//测试代码cpp.cpp#ifndef _iostream_#define _iostream_#include <iostream>#endif#ifndef _ctime_#define _ctime_#include <ctime>#endif#ifndef _conio_h_#define _conio_h_#include <conio.h>#endif#include "thp.h"using std::cout;using std::endl;int main(){ clock_t t1=clock();thpa="123123122344444444444234444444444444411222222333333333333333333333 333333333333333333333\ 342342333333333333333333333333333333333333333333333333333333333333333 3333333333333333333333\235234534563452342342344444987724352345234234234000000000000000000000 00000000000000000000000000\ 666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666 6\ 342342333333333333333333333333333333333333333333333333333333333333333 3333333333333333333333\ 235234534563452342342344444987724352345234234234000000000000000000000 00000000000000000000000000\ 666666666666666666666666666666666666666666666666666666666666666666666 666666666666666666666666666666666666666666666666666666666666666666666 6\3423423333333333333333333333333333333333333333333333333333333333333 333333333333333333333333\ 235234534563452342342344444987724352345234234234000000000000000000000 00000000000000000000000000\ 666666666666666666666666666666666666666666666666666666666666666666666 666666666666666666666666666666666666666666666666666666666666666666666 6\3423423333333333333333333333333333333333333333333333333333333333333 333333333333333333333333\ 235234534563452342342344444987724352345234234234000000000000000000000 00000000000000000000000000\ 666666666666666666666666666666666666666666666666666666666666666666666 666666666666666666666666666666666666666666666666666666666666666666666 6\3423423333333333333333333333333333333333333333333333333333333333333 333333333333333333333333\ 235234534563452342342344444987724352345234234234000000000000000000000 00000000000000000000000000\ 666666666666666666666666666666666666666666666666666666666666666666666 666666666666666666666666666666666666666666666666666666666666666666666 6\ 444444444444444444444444444444444444444444444443423452234234342";thp b="23423433444444444444444444444444444444444423423423423423\ 342342333333333333333333333333333333333333333333333333333333333333333 3333333333333333333333\ 235234534563452342342344444987724352345234234234000000000000000000000 00000000000000000000000000\ 666666666666666666666666666666666666666666666666666666666666666666666 666666666666666666666666666666666666666666666666666666666666666666666 6\3333333333323423";thp c=a/b;thp d=c*b;thp e=d+a%b;cout<<e.tostr()<<endl;cout<<"Run time="<<(clock()-t1)<<"ms"<<endl;getch();return 0;}。
小学生四则运算项目C++实现
⼩学⽣四则运算项⽬C++实现项⽬相关要求1. (完成)使⽤ -n 参数控制⽣成题⽬的个数。
2. (完成)使⽤ -r 参数控制题⽬中数值（⾃然数、真分数和真分数分母）的范围。
该参数可以设置为1或其他⾃然数。
该参数必须给定，否则程序报错并给出帮助信息。
3. (完成)⽣成的题⽬中计算过程不能产⽣负数，也就是说算术表达式中如果存在形如e1 − e2的⼦表达式，那么e1 ≥ e2。
4. (完成)⽣成的题⽬中如果存在形如e1 ÷ e2的⼦表达式，那么其结果应是真分数。
5. (完成)每道题⽬中出现的运算符个数不超过3个。
6. (完成)程序⼀次运⾏⽣成的题⽬不能重复，即任何两道题⽬不能通过有限次交换+和×左右的算术表达式变换为同⼀道题⽬。
例如，23 + 45 = 和45 + 23 = 是重复的题⽬，6 × 8 = 和8 × 6 = 也是重复的题⽬。
3+(2+1)和1+2+3这两个题⽬是重复的，由于+是左结合的，1+2+3等价于(1+2)+3，也就是3+(1+2)，也就是3+ (2+1)。
但是1+2+3和3+2+1是不重复的两道题，因为1+2+3等价于(1+2)+3，⽽3+2+1等价于(3+2)+1，它们之间不能通过有限次交换变成同⼀个题⽬。
⽣成的题⽬存⼊执⾏程序的当前⽬录下的Exercises.txt⽂件。
7. (完成)在⽣成题⽬的同时，计算出所有题⽬的答案，并存⼊执⾏程序的当前⽬录下的Answers.txt⽂件。
8. (完成)程序应能⽀持⼀万道题⽬的⽣成。
9. (完成)程序⽀持对给定的题⽬⽂件和答案⽂件，判定答案中的对错并进⾏数量统计，统计结果输出到⽂件Grade.txt。
代码规范本次项⽬的代码遵循了⾕歌代码规范(C++)，但由于⾕歌代码规范篇幅太多，所以我们⽬前只遵循了其中的部分规范，具体如下：1. 禁⽌使⽤宏2. 分号以前不加空格3. ⾏宽原则上不超过804. ⼀⾏只定义⼀个变量5. 左⼤括号前保留⼀个空格6. if, else前后都要⼀个空格7. for, while后要有⼀个空格8. return 后⾯的数值不加 ( )9. 每个⽂件应该含有版权信息及作者10. 左圆括号之后和右圆括号之前⽆空格11. 函数参数过多时，每⾏的参数变量对齐12. ⼀⽬运算符与变量之间不加空格符隔开13. 禁⽌使⽤ using 指⽰（using-directive）14. 禁⽌使⽤C++的流，⽽是⽤printf之类的替代15. 要么函数名与参数同⾏，要么所有参数并排分⾏16. 换⾏代码缩进2个空格，并且使⽤两个空格符取代制表符17. ⼆⽬以上的运算符与变量，常量之间⽤空格隔开（各类括号除外）18. 不论控制语句，循环语句后⾯的循环体有多少⾏，都必须使⽤花括号19. 普通函数，类型（含类与结构体，枚举类型），常量等使⽤⼤⼩写混合，不含下划线20. 除函数定义的左⼤括号可置于⾏⾸以外，包括函数/类/结构体/枚举声明，各种语句的左⼤括号必须置于⾏末，所有右⼤括号独⽴成⾏设计思路具体设计&关键代码ImproperFraction类构建⼀个ImproperFraction的类，然后重载这个类的四种运算 +-x÷ 以及以及六种逻辑关系'<' '==' '<=' '!=' '>' '>='判断，在后续的代码编写之中都是基于这个类进⾏运算class ImproperFraction {public :ImproperFraction(){}ImproperFraction (int Mole, int Deno, int Coef = 0) {int g = std::__gcd (Mole, Deno);g = std::max(g, 1);mole = (Mole + Coef * Deno) / g;deno = Deno / g;}ImproperFraction operator + (const ImproperFraction & rhs ) const {int DENO = deno * rhs.deno;int MOLE = mole * rhs.deno + rhs.mole * deno;ImproperFraction res = ImproperFraction (MOLE, DENO);return res;}ImproperFraction operator - (const ImproperFraction & rhs ) const {int DENO = deno * rhs.deno;int MOLE = mole * rhs.deno - rhs.mole * deno;ImproperFraction res = ImproperFraction (MOLE, DENO);return res;}ImproperFraction operator * (const ImproperFraction & rhs ) const {int DENO = deno * rhs.deno;int MOLE = mole * rhs.mole;ImproperFraction res = ImproperFraction (MOLE, DENO);return res;}ImproperFraction operator / (const ImproperFraction & rhs ) const {int DENO = deno * rhs.mole;int MOLE = mole * rhs.deno;ImproperFraction res = ImproperFraction (MOLE, DENO);return res;}bool operator < (const ImproperFraction & rhs ) const {return mole * rhs.deno < rhs.mole * deno;}bool operator == (const ImproperFraction & rhs ) const {return mole * rhs.deno == rhs.mole * deno;}bool operator != (const ImproperFraction & rhs ) const {return !(mole * rhs.deno == rhs.mole * deno);}bool operator <= (const ImproperFraction & rhs ) const {return (*this) < rhs || (*this) == rhs;}bool operator > (const ImproperFraction & rhs ) const {return !((*this) <= rhs);}bool operator >= (const ImproperFraction & rhs ) const {return (*this) > rhs || (*this) == rhs;}private :int mole = 0; // 分⼦int deno = 1; // 分母};题集的⽣成表达式的⽣成在这⾥选择的是rand() 随机⽣成运算符个数，类型以及每个被运算的数值。
C语言简单计算器实现四则运算可带括号
C语言简单计算器实现四则运算可带括号```c#include <stdio.h>#include <stdlib.h>int priority(char op)if (op == '+' ， op == '-')return 1;else if (op == '*' ， op == '/')return 2;else if (op == '(')return 0;elsereturn -1;void calculate(char op, int *numStack, int *top, char *opStack, int *opTop)int num2 = numStack[(*top)--];int num1 = numStack[(*top)--];switch (op)case '+':numStack[++(*top)] = num1 + num2; break;case '-':numStack[++(*top)] = num1 - num2; break;case '*':numStack[++(*top)] = num1 * num2; break;case '/':numStack[++(*top)] = num1 / num2; break;}int eval(char *expr)int numStack[100];char opStack[100];int numTop = -1;int opTop = -1;int num = 0;int sign = 1;while (*expr != '\0')if (*expr >= '0' && *expr <= '9')num = num * 10 + (*expr - '0');} else if (*expr == '+' ， *expr == '-')numStack[++numTop] = num * sign;num = 0;sign = (*expr == '+') ? 1 : -1;} else if (*expr == '*' ， *expr == '/')while (opTop >= 0 && priority(*expr) <=priority(opStack[opTop]))calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}opStack[++opTop] = *expr;} else if (*expr == '(')opStack[++opTop] = '(';} else if (*expr == ')')while (opStack[opTop] != '(')calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}opTop--;}expr++;}numStack[++numTop] = num * sign;while (opTop >= 0)calculate(opStack[opTop--], numStack, &numTop, opStack, &opTop);}return numStack[0];int maichar expr[100];printf("请输入表达式：");scanf("%s", expr);int result = eval(expr);printf("计算结果：%d\n", result);return 0;```以上是一个简单的C语言四则运算计算器的实现。
用C++编写四则运算
⽤C++编写四则运算⼀.基本功能随机产⽣三个运算数，两个运算符的简单四则混合运算。
做⼀道题⽬产⽣⼀道，共300题。
⼆.程序代码#include <iostream>#include <stdlib.h>#include <time.h>using namespace std;int main(){int iOperator1,iOperator2,iOperator3,op1,op2;int iCalculate,iResult;double dCalculate,dResult,dTemp;int iSum=300;//出300道四则运算题⽬cout<<"⽣成300道四则运算题"<<endl;while(iSum--){//设置种⼦srand(time(NULL));//随机值赋给参数iOperator1,iOperator2,iOperator3iOperator1=rand()%100;iOperator2=rand()%100;iOperator3=rand()%100;//随机产⽣运算符op1=rand()%4;op2=rand()%4;//判断第⼀个运算符switch(op1){case 0://判断第⼆个运算符switch(op2){case 0:iResult=iOperator1+iOperator2+iOperator3;//沥去结果⼤于100的题⽬if(iResult>100)iSum++;else{cout<<iOperator1<<"+"<<iOperator2<<"+"<<iOperator3<<"=";cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 1:iResult=iOperator1+iOperator2-iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"+"<<iOperator2<<"-"<<iOperator3<<"=";cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 2:iResult=iOperator1+iOperator2*iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"+"<<iOperator2<<"*"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 3:dTemp=iOperator1+(double)iOperator2/(double)iOperator3;//结果保留2位⼩数dResult=(int)(dTemp*100)/100.0;//沥去结果⼤于100或者分母等于0的题⽬if(dResult>100.0||iOperator3==0)iSum++;else{cout<<iOperator1<<"+"<<iOperator2<<"/"<<iOperator3<<"="; cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;}break;case 1:switch(op2){case 0:iResult=iOperator1-iOperator2+iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"-"<<iOperator2<<"+"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 1:iResult=iOperator1-iOperator2-iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"-"<<iOperator2<<"-"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;case 2:iResult=iOperator1-iOperator2*iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"-"<<iOperator2<<"*"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 3:dTemp=iOperator1-(double)iOperator2/(double)iOperator3;dResult=(int)(dTemp*100)/100.0;if(dResult>100.0||iOperator3==0)iSum++;else{cout<<iOperator1<<"-"<<iOperator2<<"/"<<iOperator3<<"="; cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;}break;case 2:switch(op2){case 0:iResult=iOperator1*iOperator2+iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"*"<<iOperator2<<"+"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 1:iResult=iOperator1*iOperator2-iOperator3;if(iResult>100)iSum++;else{cout<<iOperator1<<"*"<<iOperator2<<"-"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 2:iResult=iOperator1*iOperator2*iOperator3;if(iResult>100)iSum++;cout<<iOperator1<<"*"<<iOperator2<<"*"<<iOperator3<<"="; cin>>iCalculate;if(iCalculate==iResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 3:dTemp=iOperator1*(double)iOperator2/(double)iOperator3;dResult=(int)(dTemp*100)/100.0;if(dResult>100.0||iOperator3==0)iSum++;else{cout<<iOperator1<<"*"<<iOperator2<<"+"<<iOperator3<<"="; cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;}break;case 3:switch(op2){case 0:dTemp=(double)iOperator1/(double)iOperator2+iOperator3;dResult=(int)(dTemp*100)/100.0;if(dResult>100.0||iOperator2==0)iSum++;else{cout<<iOperator1<<"/"<<iOperator2<<"+"<<iOperator3<<"="; cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 1:dTemp=(double)iOperator1/(double)iOperator2-iOperator3;dResult=(int)(dTemp*100)/100.0;if(dResult>100.0||iOperator2==0)iSum++;else{cout<<iOperator1<<"/"<<iOperator2<<"-"<<iOperator3<<"="; cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 2:dTemp=(double)iOperator1/(double)iOperator2*iOperator3;dResult=(int)(dTemp*100)/100.0;if(dResult>100.0||iOperator2==0)iSum++;else{cout<<iOperator1<<"/"<<iOperator2<<"*"<<iOperator3<<"=";cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;case 3:dTemp=(double)iOperator1/(double)iOperator2/(double)iOperator3;dResult=(int)(dTemp*100)/100.0;if(dResult>100.0||iOperator2==0||iOperator3==0)iSum++;else{cout<<iOperator1<<"/"<<iOperator2<<"/"<<iOperator3<<"=";cin>>dCalculate;if(dCalculate==dResult)cout<<"Right"<<endl;elsecout<<"Wrong"<<endl;}break;}break;}}return 0;}三.程序截图四.简要总结实现加减乘除四则运算，沥去程序中随机形成的结果⼤于100的题⽬。
vba 四则混合运算
vba 四则混合运算VBA（Visual Basic for Applications）是一种用于Microsoft Office套件中的宏编程语言。
它可以用于自动化和定制化Office 应用程序，包括Excel、Word和PowerPoint等。
在本文中，我们将探讨如何使用VBA进行四则混合运算。
四则混合运算是指同时使用加减乘除四种基本运算符进行计算的运算。
在VBA中，我们可以使用这些运算符来进行数值计算，从而实现各种复杂的计算任务。
我们需要了解VBA中的运算符。
在VBA中，加法运算使用"+"符号表示，减法运算使用"-"符号表示，乘法运算使用"*"符号表示，除法运算使用"/"符号表示。
通过使用这些运算符，我们可以在VBA程序中进行各种数值计算。
让我们以一个简单的例子开始。
假设我们有两个变量A和B，它们分别存储了两个数字。
现在，我们想要将这两个数字相加并将结果存储在一个新的变量C中。
我们可以使用VBA的加法运算符来实现这个任务，代码如下：```Dim A As IntegerDim B As IntegerDim C As IntegerA = 10B = 5C = A + BMsgBox "两个数字的和为：" & C```在这个例子中，我们首先声明了三个整型变量A、B和C。
然后，我们给变量A和B赋值，分别为10和5。
接下来，我们使用加法运算符将A和B相加，并将结果存储在变量C中。
最后，我们使用MsgBox函数输出结果。
除了加法运算，VBA还支持减法、乘法和除法运算。
我们可以使用类似的方法来进行这些运算。
下面是一个进行四则混合运算的示例代码：```Dim A As DoubleDim B As DoubleDim C As DoubleA = 10.5B = 2.5C = (A + B) * (A - B) / (A * B)MsgBox "四则混合运算的结果为：" & C```在这个例子中，我们首先声明了三个双精度浮点型变量A、B和C。
四则运算的实现
四则运算的实现四则运算的实现可以通过编写一个简单的计算器程序来实现。
下面是一个基本的四则运算实现的示例代码：```pythondef addition(num1, num2):return num1 + num2def subtraction(num1, num2):return num1 - num2def multiplication(num1, num2):return num1 * num2def division(num1, num2):if num2 != 0:return num1 / num2else:return "除数不能为零"while True:print("请选择要进行的运算：")print("1. 加法")print("2. 减法")print("3. 乘法")print("4. 除法")print("0. 退出")choice = input("请输入选项：")if choice == '0':breaknum1 = float(input("请输入第一个数字："))num2 = float(input("请输入第二个数字："))if choice == '1':result = addition(num1, num2)elif choice == '2':result = subtraction(num1, num2)elif choice == '3':result = multiplication(num1, num2)elif choice == '4':result = division(num1, num2)else:print("无效的选项")continueprint("结果为：", result)```这个示例代码中，使用了四个函数来实现加法、减法、乘法和除法。
pta题库 sdut-oop-8 分数四则运算(类和对象)
这是一道涉及面向对象编程的题目，要求编写一个四则运算的分数计算器。
以下是Python 的一个示例代码，使用了面向对象编程的概念。
python复制代码class Fraction:def__init__(self, numerator, denominator):if denominator == 0:raise ValueError("Denominator cannot be zero")self.numerator = numeratorself.denominator = denominatordef__str__(self):return f"{self.numerator}/{self.denominator}"def__add__(self, other):lcm = self.denominator * other.denominator // self.numerator // other.numeratorresult_numerator = lcm // self.denominator * self.numerator + lcm // other.denominator * other.numeratorresult_denominator = lcmreturn Fraction(result_numerator, result_denominator)def__sub__(self, other):lcm = self.denominator * other.denominator // self.numerator // other.numeratorresult_numerator = lcm // self.denominator * self.numerator - lcm // other.denominator * other.numeratorresult_denominator = lcmreturn Fraction(result_numerator, result_denominator)def__mul__(self, other):result_numerator = self.numerator * other.numeratorresult_denominator = self.denominator * other.denominatorreturn Fraction(result_numerator, result_denominator)def__truediv__(self, other):result_numerator = self.numerator * other.denominatorresult_denominator = self.denominator * other.numeratorreturn Fraction(result_numerator, result_denominator)def__eq__(self, other):return self.numerator * other.denominator == self.denominator * other.numerator# 示例代码fraction1 = Fraction(1, 2)fraction2 = Fraction(2, 3)print(f"Fraction 1: {fraction1}")print(f"Fraction 2: {fraction2}")print(f"Addition: {fraction1 + fraction2}")print(f"Subtraction: {fraction1 - fraction2}")print(f"Multiplication: {fraction1 * fraction2}")print(f"Division: {fraction1 / fraction2}")这个代码定义了一个名为Fraction的类，该类表示一个分数。
汇编语言加减乘除四则运算实现源代码.
汇编语言加减乘除四则运算实现源代码汇编语言加减乘除四则运算实现源代码 MOVBX,AX POP AX DIV CX PUSH DX MOV DX,BX OR BX,AX JNZ DOUT1DOUT2: POP AX ADDAL,'0' CMP AL,'9' JBEDOUT3 ADD AL,'A'-'9'-1DOUT3: CALLDISP DEC BP JNZ DOUT2 POP BP POP DX POP BX POPAX RET;输入数据在DX:AX中返回;CX=0 数据为10进制;CX#0 数据为16进制DATE LABEL NEAR PUSHBX PUSH BP PUSH DI XOR AX,AX XOR DX,DXDATE1: MOVDI,AX LODSB CMP AL,'0' JB DATE7 CMP AL,'9' JA SHL DI,1 RCL DX,1 SHL DI,1 RCL DX,1 JCXZ DATE3 SHLDI,1 RCL DX,1 Jmp shortDATE4DATE3: ADD DI,BX ADCDX,BPDATE4: ADD AX,DI ADCDX,0 JMP DATE1DATE5: ADDAL,9 JMP DATE2DATE6: JCXZDATE7 CMP AL,'A' JBDATE7 CMP AL,'F' JBEDATE5 CMP AL,'a' JBDATE7 CMP AL,'f' JBEDATE5DATE7: MOV AX,DI DECSI OR DI,DX POP DI POPBP POP BX RET;数据1与数据2根据YSF1进行加减运算JSJJ LABEL NEAR MOVAX,NUM2 MOV DX,NUM2+2 CMPYSF1,'+' JZ JSJJ1 SUBNUM1,AX SBB NUM1+2,DX JMP SHORTJSJJ2JSJJ1: ADD NUM1,AX ADC NUM1+2,DX上一页[1] [2] [3] 下一页。
四则运算汇编语言程序设计
安徽工程大学《汇编语言程序设计》大作业报告班级： XXXXX 学号： XXXXXXXX 完成人： XXXXXXX任课老师： XXXXXXX 时间： XXXXXXXXXX《汇编语言程序设计》大作业任务书大作业题目：四则运算程序程序功能要求：编写一个程序，每运行一次可执行程序，可以实现加减乘除四则运算。
计算器是最简单的计算工具，简单计算器具有加、减、乘、除四项运算功能。
1.设计目标运用汇编语言，制作一个计算的程序，实现简单计算器的一般功能，能够在DOS界面下进行简单的加、减、乘、除的简单计算。
程序应有操作提示、输入和输出。
自动闪烁光标，并提示输入信息。
输入正确的数值等符号后可以进行正确的运算，程序计算其结果值并输出。
程序无需查错功能，所输入的都是正确的四则运算表达式，并且表达式中运算分量均为无正负号整数，运算符为+、-、*、/，最后结果以十进制数表示。
且程序主界面需为一个由‘*’组成边框的矩形窗口。
2.软件设计2.1程序设计的基本思想主模块：首先提供一个主界面，提示用户按要求输入具体的数据和所要进行的操作，输入完毕后给出结果。
如果输入过程中发现非法输入，则立即给与提示，程序自动刷新界面，提示继续输入。
计算显示完毕后，按提示选择是否要继续计算，不选择继续则结束。
对屏幕上输入字符串的接受，为INPUT语句段，见源代码，主要是将数字和运算符分开存放。
MATCH子程序，子程序内有三次跳转，将运算符选择正确的语句进行计算。
由于操作符只有+、-、*、/，没有涉及到括号，不用考虑括号的匹配问题。
流程图如下：图1 主模块流程图子模块：完成对数据的进一步加工处理，转换格式并得出结果。
首先根据输入调用对应的“+”、“-”、“*”、“/”四个函数模块，这是本程序的核心模块，其他部分的一些小模块都是为这几个模块服务的，大致的流程图如下图2：图2 子模块流程图3.系统调试3.1测试目标(1)在屏幕上显示一个由‘*’组成边框的矩形窗口；(2)自动闪烁光标，并提示输入信息；(3)能够完成单项表达式的输入、显示和运算；(4)编制并调试出程序。
python实现简单四则运算计算器
python实现简单四则运算计算器基本需求：1. 实现加减乘除及拓号优先级解析2. ⽤户输⼊ 1 - 2 * ( (60-30 +(-40/5) * (9-2*5/3 + 7 /3*99/4*2998 +10 * 568/14 )) - (-4*3)/ (16-3*2) )等类似公式后，必须⾃⼰解析⾥⾯的(),+,-,*,/符号和公式(不能调⽤eval等类似功能偷懒实现)，运算后得出结果正确。
基本思路：1. 根据运算优先级，先处理公⽰内所含括号中的运算。
2. 利⽤正则表达式，对输⼊的内容进⾏解析（加减乘除、数字等）3. 通过循环遍历，或者递归对待处理部分进⾏充分运算处理流程图：略直接上代码1#!/usr/bin/env python2#-*- coding:utf-8 -*-3"""4四则运算，版本1.05"""6import re7def re_set(item):8"""9对输⼊的公式进⾏规范化处理，符号转化10"""11 item = str(item)12 item = item.replace("+-","-")13 item = item.replace("-+","-")14 item = item.replace("--","+")15 item = item.replace("++","+")16 item = item.replace("*+","*")17 item = item.replace("/+","/")18return item19def multiple(item_mult):20"""21公⽰中乘除运算22 :param item_mult:23 :return:24"""25while True:26 item_mult = re_set(item_mult)27if ("*"in item_mult) or ("/"in item_mult) :28if ("*-"in item_mult) or ("/-"in item_mult):29 R_0_formula = re.search("([0-9]+\.[0-9]+|[0-9]+)((\*\-)|(\/\-))([0-9]+\.[0-9]+|[0-9]+)", item_mult).group()30else:31 R_0_formula = re.search("([0-9]+\.[0-9]+|[0-9]+)(\*|\/)([0-9]+\.[0-9]+|[0-9]+)", item_mult).group()32 num1 = re.search("^(([0-9]+\.[0-9]+)|[0-9]+)", R_0_formula).group()33 num2 = re.search("(([0-9]+\.[0-9]+)|[0-9]+)$", R_0_formula).group()34 R_1_formula = (float(num1) * float(num2)) if ("*"in R_0_formula) else (float(num1) / float(num2))35if"-"in R_0_formula:36 R_1_formula = "-" + str(R_1_formula)37 item_mult = item_mult.replace(R_0_formula,str(R_1_formula))38else:break39return item_mult40def comb(item_comb):41"""42完成加减运算、结果合并43 :param item_comb:44 :return:45"""46while True:47 item_comb = re_set(item_comb)48if ("*"in item_comb) or ("/"in item_comb):49 item_comb = multiple(item_comb)50elif ("+"in item_comb[1:]) or ("-"in item_comb[1:]):51 R_0_formula = re.search("([0-9]+\.[0-9]+|[0-9]+)(\+|\-)([0-9]+\.[0-9]+|[0-9]+)", item_comb).group()52 num1 = re.search("^(([0-9]+\.[0-9]+)|[0-9]+)", R_0_formula).group()53 num2 = re.search("(([0-9]+\.[0-9]+)|[0-9]+)$", R_0_formula).group()54if"-"in item_comb[0]:55 R_1_formula = float(num1) - float(num2) if ("+"in R_0_formula) else float(num1) + float(num2)56else:57 R_1_formula = float(num1) + float(num2) if ("+"in R_0_formula) else float(num1) - float(num2)58 item_comb = item_comb.replace(R_0_formula,str(R_1_formula))59else:60break61return item_comb62def sp(item_sp):63"""64对运算中的括号进⾏处理65 :param item_sp:66 :return:67"""68while True:69if"("in item_sp:70 R_0_formula = re.search("\(([^\(|\)]*)\)",item_sp).group()71 R_1_formula = comb(R_0_formula.replace("(","").replace(")",""))72 item_sp = item_sp.replace(R_0_formula,str(R_1_formula))73else:74break75return item_sp76def coms(item_coms):77"""78最终合并79 :param item_coms:80 :return:81"""82 item_coms = re_set(item_coms)83 item_coms = sp(item_coms)84 item_coms = comb(item_coms)85return item_coms86 formula = input("请输⼊计算公式——>：").strip()87 formula = formula.replace("","")88print(eval(formula))89print(coms(formula))四则计算器1.01#！/usr/bin/env python2# -*- coding : utf-8 -*-3"""4⽤于常规四则运算，版本1.15"""6import re7def func_reset(func):8"""9对输⼊的公式进⾏规范化处理，符号转化10 :param func: 输⼊的原始公式11 :return: 符号等价替换完成的公⽰12"""13 func = str(func)14 func = func.replace("+-","-").replace("-+","-").replace("++","+").replace("--","+").replace("*+","*") 15return func16def multiple(func_mul):17"""18公⽰中乘除运算19 :param func_mul: 待处理，含有*，/ 运算符号的公⽰20 :return: 将* ，/ 运算完成的结果21"""22while ("*"in func_mul) or ("/"in func_mul):23 func_mul = func_reset(func_mul)24if ("*-"in func_mul) or ("/-"in func_mul):25 Re_0_func = re.search("([0-9]+(\.[0-9]+)?)((\*\-)|(\/\-))([0-9]+(\.[0-9]+)?)",func_mul).group() 26else:Re_0_func = re.search("([0-9]+(\.[0-9]+)?)(\*|\/)([0-9]+(\.[0-9]+)?)",func_mul).group()27 num_0 = re.search("^([0-9]+(\.[0-9]+)?)",Re_0_func).group()28 num_1 = re.search("([0-9]+(\.[0-9]+)?)$",Re_0_func).group()29 Re_1_func = (float(num_0)*float(num_1)) if ("*"in Re_0_func) else (float(num_0)/float(num_1)) 30if"-"in Re_0_func:31 Re_1_func = "-" + str(Re_1_func)32 func_mul = func_mul.replace(Re_0_func, str(Re_1_func))33return func_mul3435def comb(func_coms):36"""37完成加减运算、结果合并38 :param func_coms: 待处理公⽰39 :return: 处理完成+，-的结果40"""41while True:42 func_coms = func_reset(func_coms)43if ("*"in func_coms) or ("/"in func_coms):44 func_coms = multiple(func_coms)45elif ("+"in func_coms[1:]) or ("-"in func_coms[1:]):46 func_coms = func_reset(func_coms)47 Re_0_func = re.search("([0-9]+(\.[0-9]+)?)(\+|\-)([0-9]+(\.[0-9]+)?)",func_coms).group()48 num_0 = re.search("^([0-9]+(\.[0-9]+)?)",Re_0_func).group()49 num_1 = re.search("([0-9]+(\.[0-9]+)?)$",Re_0_func).group()50if"-"in func_coms[0] :51 Re_1_item = (float(num_0)-float(num_1)) if("+"in Re_0_func) else (float(num_0)+float(num_1)) 52else:53 Re_1_item = (float(num_0)+float(num_1)) if("+"in Re_0_func) else (float(num_0)-float(num_1))54 func_coms = func_coms.replace(Re_0_func,str(Re_1_item))55else:56return func_coms5758def spl(func_spl):59"""60对运算中的括号进⾏处理61 :param func_spl: 对运算中的括号进⾏处理，可以⽤循环，或者递归62 :return: 公式内包含的括号及其内部运算处理完成63"""64while"("in func_spl:65 spl_0_func = re.search("\([^\(|\)]*\)",func_spl).group()66 spl_1_func = comb(spl_0_func.replace("(","").replace(")",""))67 func_spl = func_spl.replace(spl_0_func,str(spl_1_func))68return func_spl69while True:70 formula = input("请输⼊计算公式，退出（q）——>").strip()71 formula = formula.replace("","")72if formula == "q":73break74elif re.search("[^\d|\(|\)|\+|\-|\*|\/]*",formula).group():75print("输⼊有误，仅⽀持四则运算----->",re.search("[^\d|\(|\)|\+|\-|\*|\/]*",formula).group())76break77print(eval(formula)) # ⽤于输出检验结果78 formula = spl(formula)79 formula = comb(formula)80print(formula)四则计算器1.1待续……。
大一c语言编程四则运算
大一c语言编程四则运算四则运算是我们日常生活中最常见的数学运算，它包括加法、减法、乘法和除法。
在计算机编程中，四则运算是非常基础的知识，也是必不可少的。
本文将介绍如何使用c语言实现四则运算。
加法加法是最基本的运算之一，在c语言中可以使用加号（+）来实现。
例如，我们要计算2+3的结果，可以写成：int result = 2 + 3;这样就可以将计算结果赋值给变量result。
在c语言中，加法还可以用于字符串拼接，例如：char str1[] = "hello";char str2[] = "world";char str3[12];strcpy(str3, str1);strcat(str3, str2);printf("%s", str3);这段代码会输出"helloworld"，其中strcpy函数用于将str1复制到str3中，而strcat函数则用于将str2拼接到str3中。
减法减法是另一种基本的运算，可以使用减号（-）来实现。
例如，我们要计算5-3的结果，可以写成：int result = 5 - 3;这样就可以将计算结果赋值给变量result。
乘法乘法也是一种基本的运算，可以使用乘号（*）来实现。
例如，我们要计算2×3的结果，可以写成：int result = 2 * 3;这样就可以将计算结果赋值给变量result。
除法除法也是一种基本的运算，可以使用除号（/）来实现。
需要注意的是，在c语言中，整数除以整数的结果仍为整数，因此如果要得到小数结果，需要将其中一个操作数转换为浮点数。
例如，我们要计算5÷2的结果，可以写成：float result = 5.0 / 2;这样就可以将计算结果赋值给变量result，并且得到一个小数结果。
综合运算除了以上四种基本运算，c语言还可以进行更加复杂的运算，例如混合运算。
汇编语言课程设计报告——实现加减乘除四则运算的计算器
汇编语言课程设计报告( 2011 -- 2012 年度第 2 学期)实现加减乘除四则运算的计算器专业 计算机科学与技术 学生姓名班级学号指导教师完成日期目录目录错误!未定义书签。
1 概述错误!未定义书签。
设计目的错误!未定义书签。
设计内容错误!未定义书签。
2 系统需求分析错误!未定义书签。
系统目标错误!未定义书签。
主体功能错误!未定义书签。
开发环境错误!未定义书签。
3 系统概要设计错误!未定义书签。
系统的功能模块划分错误!未定义书签。
系统流程图错误!未定义书签。
4系统详细设计错误!未定义书签。
5 测试错误!未定义书签。
测试方案错误!未定义书签。
测试结果错误!未定义书签。
6 小结错误!未定义书签。
参考文献错误!未定义书签。
附录错误!未定义书签。
附录源程序清单错误!未定义书签。
实现加减乘除四则运算的计算器1 概述设计目的本课程设计是在学完教学大纲规定的全部内容、完成所有实践环节的基础上，旨在深化学生学习的汇编语言课程基本知识，进一步掌握汇编语言程序设计方法，提高分析问题、解决问题的综合应用能力。
设计内容能实现加、减、乘、除的计算；该程序接受的是16进制数；执行时，需要在文件名后直接跟上计算表达式，如在命令提示符下执行结果如下：c:\tasm>js 3+252 系统需求分析系统目标本次汇编语言课程设计的最终目的是要实现一个简单加减乘除四则运算的计算器，要求编写一个程序，每运行一次可执行程序，可以实现数的加减乘除四则运算。
比如，十进制数的加减乘除四则运算。
我们曾经学习过两个具体数字进行加减法运算，但是对于简单计算器用汇编语言实现难点在于这两个要做运算的数是未知的，是由自己调用中断输入到屏幕上并要用程序存储起来的数，然后才能对这两个数进行运算，而且做的是加法运算、减法运算乘法运算还是除法运算也未可知，为此我们还要判断用户所输入的运算是四则运算中的哪一个运算。
此外，运算过程中的进位或是借位，选择用什么样的方式进行输出，如何实现清屏等也是要解决的问题。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
汇编程序大作业云南大学软件学院实验报告指导教师 (签名):实验内容：1．设计一个功能完善的四则运算器：①程序有友好的运行界面；②可以方便的输入输出2，10，16进制数据（要求可以处理4位的数据）；③可以方便的对数据进行四则运算；④要求程序能够处理基本的错误信息；⑤程序要求菜单控制；⑥其他程序简介：该程序采用了主程序、子程序、宏相结合的编写方式，通过主程序调用了加、减、乘、除的子程序，在这四个子程序中有分别调用了二、十、十六进制输入输出、进制间转化的子程序。
在数值转化为ASCII码的部分，定义了宏进行调整输出。
程序实现了16位的二进制、4位的十进制、4位的十六进制的加、减、乘、除运算，并可以通过用户的选择将其转化为其他相应的进制。
其中乘法运算的进制转化功能尚不完善，当运算结果超过4位时不能正确的将结果进行输出并进行进制转化。
子过程：addition：加法部分subtraction：减法部分multiplication：乘法部分division：除法部分b_in：二进制输入hd_in：十六进制、十进制输入b_out：二进制输出btod：二进制转化十进制并输出both：二进制转化十六进制并输出宏：btth：将数值转化为ASCII码保存算法说明：二进制计算时，要求输入0和1，从高到低为输入，将先输进的数*2+后输入的数，保存到寄存器中，如 1011则按（（1*2+0）*2+1）*2+1十进制计算时，要求输入0-9的整数，从高到低输入，将先输进的数*10+后输进的数，保存到寄存器中，如9817 则按（（9*10+8）*10+1）*10+7十进制计算时，要求输入0-F的整数，从高到低输入，将先输进的数*10H+后输进的数，保存到寄存器中，如AD17 则按（（A*10H+D）*10H+1）*10H+7通过add、sub、mul、div等汇编指令进行计算。
二进制输出，从高位到低位按位依次保存到dl中，加30h后输出十进制输出，将结果分别除以10000、（上一步余数除）1000、（上一步余数除）100、（上一步余数除）10将商分别加30h后输出，将最后的余数加上30h后输出十六进制输出，从高到低每四位依次输出与9比较，大于9加37h调整,小于9加30h 调整程序流程及实验结果：主程序部分：提示用户进行运算符号的选择，并进行子程序部分的调用四则运算部分流程：四则运算的加、减、乘、除四部分子程序的流程大致相同，此处采用同一个流程图表示，该部分提示用户进行进制选择，跳转的相应位置并进行相应的运算，调用输入输出子程序，对结果进行进制转化二进制输入流程：该部分进行二进制数的输入，通过移位将先输入的数保存到高位，后输入的数保存到低位，将最终结果保存到bx中二进制输出：该部分将运算结果以2进制的形式输出，通过加30h将数值转化为ASCII码输出十、十六进制数的输入该部分实现十及十六进制数的输入，将最终结果保存到bx中；二进制转十进制并输出该部分通过将得到的二进制数求商取余的方式将最高位的取到商中并输出；二进制转十六进制：该部分通过移位的方式将二进制数转化为16进制输出，其中判断了所输出值与9的大小关系，大于9则加37h调整，小于9则加30h调整加法部分：二进制加法，并将结果转化为10进制二进制加法，并将结果转化为16进制：十进制加法，并将结果转化为二进制：十进制加法，并将结果转化为16进制：十六进制加法，并将结果转化为二进制：十六进制加法，并将结果转化为十进制减法部分：二进制减法，并将结果转化为十进制输出：二进制减法并将结果转化为十六进制输出：十进制减法，并将结果转化为二进制输出：十进制减法，并将结果转化为十六进制输出：十六进制减法，并将结果转化为二进制输出：十六进制减法，并将结果转化为10进制输出：乘法部分：二进制乘法，并结果转化为10进制输出：二进制乘法并将结果转化为16进制输出：十进制乘法并将结果转化为二进制输出十进制乘法，并将结果转化为16进制输出：十六进制乘法，并将结果转化为二进制输出：十六进制乘法，并将结果转化为十进制输出：除法部分：二进制除法，并将结果转化为十进制输出：二进制除法，并将结果转化为16进制输出：十进制除法，并将结果转化为二进制输出:十进制除法，并将结果转化为16进制输出：十六进制除法，并将结果转化为二进制输出：十六进制除法，并将结果转化为10进制输出：代码：data segmentnote1 db 'Input a-->add,b-->sub,c-->mul,d--div',0ah,0dh,'$'note2 db 0ah,0dh,'Input a-->binary,b-->decimal,c--hexadecimal',0ah,0dh,'$' note3 db 0ah,0dh,'Input addend' ,0ah,0dh,'$'note4 db 0ah,0dh,'Input another addend', 0ah,0dh,'$'note5 db 0ah,0dh,'The answer is',0ah,0dh,'$'note6 db 0ah,0dh,'Change the answer to a-->decimal,b-->hexadecimal,any other key-->exit',0ah,0dh,'$'note7 db 0ah,0dh,'Change the answer to a-->binary,b-->hexadecimal,any other key-->exit',0ah,0dh,'$'note8 db 0ah,0dh,'Change the answer to a-->binary,b-->decimal,any other key-->exit',0ah,0dh,'$'note9 db 0ah,0dh,'Input minuend', 0ah,0dh,'$'note10 db 0ah,0dh,'Input subtrahend', 0ah,0dh,'$'note11 db 0ah,0dh,'Input multiplicand' ,0ah,0dh,'$'note12 db 0ah,0dh,'Input another multiplicand' ,0ah,0dh,'$'note13 db 0ah,0dh,'Input dividend', 0ah,0dh,'$'note14 db 0ah,0dh,'Input divisor', 0ah,0dh,'$'num dw 0num1 dw 0num2 dw 0sig db ?data endscode segmentassume ds:data,cs:codestart:mov ax,datamov ds,axlea dx,note1mov ah,09hint 21hm1:mov ah,01hint 21hcmp al,'a'je adcmp al,'b'je subtcmp al,'c'je multcmp al,'d'je divijmp m1ad:call additionjmp over计算机组成原理与汇编语言程序设计（2013）subt:call subtractionjmp overmult:call multiplicationjmp overdivi:call divisionover:mov ah,01hint 21hmov ah,4chint 21haddition proclea dx,note2mov ah,09hint 21hmov ah,01hint 21hmov sig,alcmp al,'a'je b_addcmp al,'b'je d_addcmp al,'c'je h_addjmp a_endb_add:lea dx,note3mov ah,09hint 21hcall b_inmov num,bxlea dx,note4mov ah,09hint 21hcall b_inlea dx,note5mov ah,09hint 21hmov ax,numadd bx,axcall b_out;此处存在bug,若产生进位不能进行输出,需提示用户只进行15位的运算lea dx,note6mov ah,09hint 21hmov ah,01h计算机组成原理与汇编语言程序设计（2013）int 21hcmp al,'a'je btdcmp al,'b'je bthjmp a_endbtd:lea dx,note5mov ah,09hint 21hcall btodjmp a_endbth:lea dx,note5mov ah,09hint 21hcall btohjmp a_endd_add:lea dx,note3mov ah,09hint 21hcall hd_inmov num,bxlea dx,note4mov ah,09hint 21hcall hd_inmov ax,numadd bx,axpush bxlea dx,note5mov ah,09hint 21hcall btodlea dx,note7mov ah,09hint 21hmov ah,01int 21hcmp al,'a'je dtbcmp al,'b'je dthjmp a_enddtb:lea dx,note5mov ah,09h计算机组成原理与汇编语言程序设计（2013）int 21hpop bxcall b_outjmp a_enddth:lea dx,note5mov ah,09hint 21hpop bxcall btohjmp a_endh_add:lea dx,note3mov ah,09hint 21hcall hd_inmov num,bxlea dx,note4mov ah,09hint 21hcall hd_inmov ax,numadd bx,axlea dx,note5mov ah,09hint 21hcall btoh;此处存在bug,当产生进位是，不能对进位进行输出lea dx,note8mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je htbcmp al,'b'je htdjmp a_endhtb:lea dx,note5mov ah,09hint 21hcall b_outjmp a_endhtd:lea dx,note5mov ah,09hint 21hcall btod计算机组成原理与汇编语言程序设计（2013）jmp a_enda_end:retaddition endpsubtraction proclea dx,note2mov ah,09hint 21hmov ah,01hint 21hmov sig,alcmp al,'a'je b_subcmp al,'b'je d_subcmp al,'c'je h_subjmp s_endb_sub:lea dx,note9mov ah,09hint 21hcall b_inmov num,bxlea dx,note10mov ah,09hint 21hcall b_inmov ax,numxchg ax,bxsub bx,axlea dx,note5mov ah,09hint 21hcall b_outlea dx,note6mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je btdcmp al,'b'je bthjmp s_end计算机组成原理与汇编语言程序设计（2013）d_sub:lea dx,note9mov ah,09hint 21hcall hd_inmov num,bxlea dx,note10mov ah,09hint 21hcall hd_inmov ax,numxchg ax,bxsub bx,axpush bxlea dx,note5mov ah,09hint 21hcall btodlea dx,note7mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je dtbcmp al,'b'je dthjmp s_endh_sub:lea dx,note9mov ah,09hint 21hcall hd_inmov num,bxlea dx,note10mov ah,09hint 21hcall hd_inmov ax,numxchg ax,bxsub bx,axlea dx,note5mov ah,09hint 21hcall btohlea dx,note8计算机组成原理与汇编语言程序设计（2013）mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je htbcmp al,'b'je htdjmp s_ends_end:retsubtraction endpmultiplication proclea dx,note2mov ah,09hint 21hmov ah,01hint 21hmov sig,alcmp al,'a'je b_mulcmp al,'b'je d_mulcmp al,'c'je h_mulb_mul:lea dx,note11mov ah,09hint 21hcall b_inmov num,bxlea dx,note12mov ah,09hint 21hcall b_inmov ax,nummul bxmov num1,dxmov num2,axlea dx,note5mov ah,09hint 21hmov num1,dxmov bx,dxcall b_out计算机组成原理与汇编语言程序设计（2013）mov ax,num2mov bx,axcall b_outlea dx,note6mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je m_btdcmp al,'b'je m_bthjmp m_endm_btd:lea dx,note5;此处错误，尚需修改mov ah,09hint 21hmov dx,num1mov bx,dxcall btodmov ax,num2mov bx,axcall btodjmp m_endm_bth:lea dx,note5mov ah,09hint 21hmov dx,num1mov bx,dxcall btohmov ax,num2mov bx,axcall btohd_mul:lea dx,note11mov ah,09hint 21hcall hd_inmov num,bxlea dx,note12mov ah,09hint 21hcall hd_inmov ax,nummul bxpush ax计算机组成原理与汇编语言程序设计（2013）lea dx,note5mov ah,09hint 21hpop axpush axmov bx,axcall btodlea dx,note7mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je m_dtbcmp al,'b'je m_dthm_dtb:lea dx,note5mov ah,09hint 21hpop axmov bx,axcall b_outjmp m_endm_dth:lea dx,note5mov ah,09hint 21hpop axmov bx,axcall btohh_mul:lea dx,note11mov ah,09hint 21hcall hd_inmov num,bxlea dx,note12mov ah,09hint 21hcall hd_inmov ax,nummul bxpush axlea dx,note5mov ah,09hint 21h计算机组成原理与汇编语言程序设计（2013）pop axpush axmov bx,axcall btohlea dx,note8mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je m_htbcmp al,'b'je m_htdm_htb:lea dx,note5mov ah,09hint 21hpop axmov bx,axcall b_outjmp m_endm_htd:lea dx,note5mov ah,09hint 21hpop axmov bx,axcall btodm_end:retmultiplication endpdivision proclea dx,note2mov ah,09hint 21hmov ah,01hint 21hmov sig,alcmp al,'a'je b_divcmp al,'b'je d_divcmp al,'c'je h_divjmp d_endb_div:lea dx,note13计算机组成原理与汇编语言程序设计（2013）mov ah,09hint 21hcall b_inmov num,bxlea dx,note14mov ah,09hint 21hcall b_inmov ax,numcwdxor dx,dxdiv bxmov num1,axmov num2,dxlea dx,note5mov ah,09hint 21hmov bx,num1call b_outmov cx,6l:mov dl,'.'mov ah,02hint 21hloop lmov bx,num2call b_outlea dx,note6mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je d_btdcmp al,'b'je d_bthjmp d_endd_btd:lea dx,note5mov ah,09hint 21hmov bx,num1call btodmov cx,6l4:mov dl,'.'mov ah,02hloop l4mov bx,num2 call btodjmp d_endd_bth:lea dx,note5 mov ah,09hint 21hmov bx,num1 call btohmov cx,6l5:mov dl,'.'mov ah,02hint 21hloop l5mov bx,num2 call btohjmp d_endd_div:lea dx,note13 mov ah,09hint 21hcall hd_inmov num,bxlea dx,note14 mov ah,09hint 21hcall hd_inmov ax,numcwdxor dx,dxdiv bxmov num1,ax mov num2,dx lea dx,note5 mov ah,09hint 21hmov bx,num1 call btodmov cx,6l2:mov dl,'.'mov ah,02hint 21hloop l2mov bx,num2lea dx,note7 mov ah,09hint 21hmov ah,01hint 21hcmp al,'a'je d_dtbcmp al,'b'je d_dthjmp d_endd_dtb:lea dx,note5 mov ah,09hint 21hmov bx,num1 call b_outmov cx,6l6:mov dl,'.'mov ah,02hint 21hloop l6mov bx,num2 call b_outjmp d_endd_dth:lea dx,note5 mov ah,09hint 21hmov bx,num1 call btohmov cx,6l7:mov dl,'.'mov ah,02hint 21hloop l7mov bx,num2 call btohjmp d_endh_div:lea dx,note13 mov ah,09hint 21hcall hd_inmov num,bxlea dx,note14 mov ah,09hcall hd_in mov ax,num cwdxor dx,dxdiv bxmov num1,ax mov num2,dx lea dx,note5 mov ah,09h int 21hmov bx,num1 call btohmov cx,6l3:mov dl,'.' mov ah,02h int 21hloop l3mov bx,num2 call btohlea dx,note8 mov ah,09h int 21hmov ah,01h int 21hcmp al,'a' je d_htbcmp al,'b' je d_htdjmp d_endd_htb:lea dx,note5 mov ah,09h int 21hmov bx,num1 call b_out mov cx,6l8:mov dl,'.' mov ah,02h int 21hloop l8mov bx,num2 call b_out jmp d_endd_htd:lea dx,note5计算机组成原理与汇编语言程序设计（2013）mov ah,09hint 21hmov bx,num1call btodmov cx,6l9:mov dl,'.'mov ah,02hint 21hloop l9mov bx,num2call btodjmp d_endd_end:retdivision endpb_in procxor dx,dxmov bx,2mov cx,16bin2:mov ah,1int 21hxor ah,ahsub al,30hadd dx,axmov ax,dxcmp cx,1je bin1mul bxbin1:mov dx,axloop bin2mov bx,dxretb_in endpb_out procmov ch,8mov cl,1mov dh,bhbot1:rol dx,cland dl,01hadd dl,30hmov ah,02hint 21hdec chja bot1mov ch,8mov dh,bl bot2:rol dx,cland dl,01h add dl,30h mov ah,02h int 21hdec chcmp ch,0ja bot2retb_out endpbtth macroand dx,0div bxmov cx,dxadd al,30h mov dl,almov ah,02h int 21hmov ax,cx endmbtod procmov ax,bxmov bx,10000 btthmov bx,1000 btthmov bx,100 btthmov bx,10btthadd al,30h mov dl,almov ah,02h int 21hretbtod endpbtoh procxor dx,dxmov cl,4mov dh,bh bth1:rol dx,cl cmp dl,9ja bth3add dl,30h jmp bth4 bth3:add dl,37h bth4:mov ah,2int 21hxor dl,dl dec chcmp ch,0ja bth1mov dh,bl mov ch,2mov cl,4 bth2:rol dx,cl cmp dl,9ja bth5add dl,30h jmp bth6 bth5:add dl,37h bth6:mov ah,2int 21hxor dl,dl dec chcmp ch,0ja bth2retbtoh endphd_in procxor dx,dx cmp sig,'c' jne din3mov bx,16 jmp din4 din3:mov bx,10 din4:mov cx,4 din1:mov ah,01h int 21hxor ah,ahja hin1 sub al,30h jmp hin2 hin1:sub al,37h hin2:add dx,ax mov ax,dx cmp cx,1 je din2mul bxdin2:mov dx,ax loop din1 mov bx,dx rethd_in endpcode ends end start。