任意两个整数之间的四则运算课程设计.docx
《任意两个整数之间的四则运算课程设计.docx》由会员分享，可在线阅读，更多相关《任意两个整数之间的四则运算课程设计.docx（22页珍藏版）》请在冰豆网上搜索。
任意两个整数之间的四则运算课程设计
课程设计报告
课程名称：
信息系统开发语言
（二）
学期：
2013-2014学年第2学期
学时学分：
64学时4学分
专业班级：
信管1
学号：
姓名：
指导老师：
提交日期：
2014年6月10日
一、课程设计目的
通过课程设计需要达到三个目的：
第一是检验和巩固专业知识。
通过课程设计，有助于加深我们对C++这门课程的理解，我们在课堂上学的都是基础理论知识，对于如何用程序语言来描述所学知识还是有一定难度。
通过课程设计，我们可以真正理解其内涵。
第二是提高综合素质和能力。
通过课程设计，逐渐培养学生的编程能力、用计算机解决实际问题的能力。
程序设计能直接有效地训练我们分析问题、解决问题的能力。
第三是有利于培养认真严谨的学习态度。
在程序设计过程里，当我们入程序代码的时候，如果不够认真或细心，就可能导致语法错误，从而无法得出运行结果。
我们反复调试，反复修改的过程，可以培养我们认真严谨的作风。
二、问题描述与分析
1、问题描述：
题号1：
两个任意长度整数之间的四则运算
总体需求：
任意给定两个数字，计算它们之间的加减乘除结果。
功能需求：
（1）输入并保存两个整数,长度不限。
（2）通过菜单选择运算类型并输出结果。
用户界面：
输入:
输入两个整数，长度不限
输出:
（1）应用程序正常运行后，要在屏幕上显示一个文字菜单。
（2）要求用户输入数据时，要给出清晰明确的提示信息，包括输入的数据内容、格式及结束方式等。
2、问题分析：
本程序要求实现任意长度的两个整数的加减乘除的运算。
由题意得，题目的难点在于任意长度，计算的数值和结果精度是任意的。
但是在C++语言中定义的类型中精度最多只有二十多位，因而采用数组存储的方式来存放数字。
运用do...While和switch语句进行选择判断。
假设字符串为sa,sb。
定义大数为a,b,c。
并分别把sa和sb赋值给a和b。
定义一个int型变量flag，并且给flag赋初始值为0。
（1）当输入值为1时，case1:
c=a+b,调用函数重载，进行加法的运算。
因为flag=1不等于0，所以输出c的结果。
（2）当输入值为2时，case2:
c=a+b,调用函数重载，进行减法的运算。
因为flag=2不等于0，所以输出c的结果。
（3）当输入值为3时，case3:
c=a+b,调用函数重载，进行乘法的运算。
因为flag=3不等于0，所以输出c的结果。
（4）当输入值为4时，case4:
c=a+b,调用函数重载，进行除法的运算。
因为flag=4不等于0，所以输出c的结果。
（5）当输入值为0时，跳出switch这个选择语句，因为flag=0等于0，所以又进入do...while循环语句。
（6）当输入值为其他时，执行default语句。
四、算法分析、设计与描述
本题要求任意长度的整数，所以采用数组存储的方式来存放和表示大整数。
一个数组元素，存放大整数中的一位。
用字符串作为文本的数据类型。
定义一个类为大数，如classBigNum。
定义一个比较大的整型数组，控制位数为500，如inta[500]；构造一个BigNum的函数，如BigNum（）{len=1;memset（a,0,sizeof（a））；将一个int类型的变量转化为大数，如BigNum（constint）;将一个字符串类型的变量转化为大数，如BigNum（constchar*）;重载赋值、输入输出、加减乘除等运算符。
通过对+，-，*，/运算符的重新定义，使它们可以完成对对象加减乘除的运算。
重载赋值运算符，大数之间就行赋值运算，如BigNum&BigNum:
:
operator=（constBigNum&n）。
程序开始，运行主函数，虽然需要进行多次判断选择，但是每一次都是判断同一表达式的值，就没必要在每一个嵌套的if语句中都计算一遍表达式的值，为此用switch语句来解决这问题。
所以运用do...While和switch语句进行选择判断。
假设字符串为sa,sb。
定义大数为a,b,c。
并分别把sa和sb赋值给a和b。
定义一个int型变量flag，并且给flag赋初始值为0。
（1）当输入值为1时，case1:
c=a+b,调用函数重载，进行加法的运算。
因为flag=1不等于0，所以输出c的结果。
（2）当输入值为2时，case2:
c=a+b,调用函数重载，进行减法的运算。
因为flag=2不等于0，所以输出c的结果。
3）当输入值为3时，case3:
c=a+b,调用函数重载，进行乘法的运算。
因为flag=3不等于0，所以输出c的结果。
（4）当输入值为4时，case4:
c=a+b,调用函数重载，进行除法的运算。
因为flag=4不等于0，所以输出c的结果。
（5）当输入值为0时，跳出switch这个选择语句，因为flag=0等于0，所以又进入do...while循环语句。
（6）当输入值为其它数时，则是default语句。
五、程序设计
1、程序设计的基本思路：
ClassBigNum//大数运算类的定义
{
private:
inta[500];//可以控制大数的位数
intlen;//大数长度
public:
BigNum（）{len=1;memset（a,0,sizeof（a））;}//构造函数
BigNum（constint）;//将一个int类型的变量转化为大数
BigNum（constchar*）;//将一个字符串类型的变量转化为大数
BigNum（constBigNum&）;//复制构造函数
BigNum&operator=（constBigNum&）;//重载赋值运算符，大数之间进行赋值运算
friendistream&operator>>（istream&,BigNum&）;//重载输入运算符
friendostream&operator<<（ostream&,BigNum&）;//重载输出运算符
BigNumoperator+（constBigNum&）const;//重载加法运算符，两个大数之间的相加运算
BigNumoperator-（constBigNum&）const;//重载减法运算符，两个大数之间的相减运算
BigNumoperator*（constBigNum&）const;//重载乘法运算符，两个大数之间的相乘运算
BigNumoperator/（constint&）const;//重载除法运算符，大数对一个整数进行相除运算
intoperator%（constint&）const;//大数对一个int类型的变量进行取模运算
booloperator>（constBigNum&T）const;//大数和另一个大数的大小比较
booloperator>（constint&t）const;//大数和一个int类型的变量的大小比较
voidprint（）;//输出大数
2、类BigNum的UML图如下：
BigNum
-a[500]：
int
-len:
int
+BigNum（constint）
+BigNum（constchar*）
+BigNum（constBigNum&）
+operator=（constBigNum&）：
BigNum
+operator>>（istream&,BigNum&）：
friendistream
+operator<<（ostream&,BigNum&）：
friendostream
+operator+（constBigNum&）const：
BigNum
+operator-（constBigNum&）const：
BigNum
+operator*（constBigNum&）const：
BigNum
+operator/（constint&）const：
BigNum
+operator%（constint&）const：
int
+operator>（constBigNum&T）const：
bool
+operator>（constint&t）const：
bool
+print（）：
void
2．程序代码及说明
#include//预处理命令，调用标准输入输出头文件iostream
#include//调用字符串文件
#include//调用声明“流操作符”的头文件
#include//调用标准库的算法的头文件
#include//调用字符串的头文件
usingnamespacestd;//使用名称空间std
#defineMAXN9999//宏定义，用MAXN代替9999
#defineMAXSIZE10//宏定义，用MAXSIZE代替10
#defineDLEN4//宏定义，用DLEN代替4
classBigNum//大数运算类的定义
{
private:
inta[500];//可以控制大数的位数
intlen;//大数长度
public:
BigNum（）{len=1;memset（a,0,sizeof（a））;}//构造函数
BigNum（constint）;//将一个int类型的变量转化为大数
BigNum（constchar*）;//将一个字符串类型的变量转化为大数
BigNum（conststring&src）;
BigNum（constBigNum&）;//复制构造函数
BigNum&operator=（constBigNum&）;//重载赋值运算符，大数之间进行赋值运算
friendistream&operator>>（istream&,BigNum&）;//重载输入运算符
friendostream&operator<<（ostream&,BigNum&）;//重载输出运算符
BigNumoperator+（constBigNum&）const;//重载加法运算符，两个大数之间的相加运算
BigNumoperator-（constBigNum&）const;//重载减法运算符，两个大数之间的相减运算
BigNumoperator*（constBigNum&）const;//重载乘法运算符，两个大数之间的相乘运算
BigNumoperator/（constint&）const;//重载除法运算符，大数对一个整数进行相除运算
intoperator%（constint&）const;//大数对一个int类型的变量进行取模运算
booloperator>（constBigNum&T）const;//大数和另一个大数的大小比较
booloperator>（constint&t）const;//大数和一个int类型的变量的大小比较
voidprint（）;//输出大数
};
BigNum:
:
BigNum（constintb）//将一个int类型的变量转化为大数
{
intc,d=b;
len=0;
memset（a,0,sizeof（a））;//把从a开始的20个值设置为0
while（d>MAXN）
{
c=d-（d/（MAXN+1））*（MAXN+1）;
d=d/（MAXN+1）;
a[len++]=c;
}
a[len++]=d;
}
BigNum:
:
BigNum（constchar*s）//将一个字符串类型的变量转化为大数
{
intt,k,index,l,i;
memset（a,0,sizeof（a））;
l=strlen（s）;
len=l/DLEN;
if（l%DLEN）
len++;
index=0;
for（i=l-1;i>=0;i-=DLEN）
{
t=0;
k=i-DLEN+1;
if（k<0）
k=0;
for（intj=k;j<=i;j++）
t=t*10+s[j]-'0';
a[index++]=t;
}
}
BigNum:
:
BigNum（conststring&src）
{
constchar*s=src.c_str（）;
intt,k,index,l,i;
memset（a,0,sizeof（a））;
l=strlen（s）;
len=l/DLEN;
if（l%DLEN）
len++;
index=0;
for（i=l-1;i>=0;i-=DLEN）
{
t=0;
k=i-DLEN+1;
if（k<0）
k=0;
for（intj=k;j<=i;j++）
t=t*10+s[j]-'0';
a[index++]=t;
}
}
BigNum:
:
BigNum（constBigNum&T）:
len（T.len）//复制构造函数的实现
{
inti;
memset（a,0,sizeof（a））;
for（i=0;ia[i]=T.a[i];
}
BigNum&BigNum:
:
operator=（constBigNum&n）//重载赋值运算符，大数之间进行赋值运算
{
inti;
len=n.len;
memset（a,0,sizeof（a））;
for（i=0;ia[i]=n.a[i];
return*this;
}
istream&operator>>（istream&in,BigNum&b）//重载输入运算符
{
charch[MAXSIZE*4];
inti=-1;
in>>ch;
intl=strlen（ch）;
intcount=0,sum=0;
for（i=l-1;i>=0;）
{
sum=0;
intt=1;
for（intj=0;j<4&&i>=0;j++,i--,t*=10）
{
sum+=（ch[i]-'0'）*t;
}
b.a[count]=sum;
count++;
}
b.len=count++;
returnin;
}
ostream&operator<<（ostream&out,BigNum&b）//重载输出运算符
{
inti;
out<for（i=b.len-2;i>=0;i--）
{
out.width（DLEN）;
out.fill（'0'）;
out<}
returnout;
}
BigNumBigNum:
:
operator+（constBigNum&T）const//两个大数之间的相加运算
{
BigNumt（*this）;
inti,big;//位数
big=T.len>len?
T.len:
len;
for（i=0;i{
t.a[i]+=T.a[i];
if（t.a[i]>MAXN）
{
t.a[i+1]++;
t.a[i]-=MAXN+1;
}
}
if（t.a[big]!
=0）
t.len=big+1;
else
t.len=big;
returnt;
}
BigNumBigNum:
:
operator-（constBigNum&T）const//两个大数之间的相减运算
{
inti,j,big;
boolflag;
BigNumt1,t2;
if（*this>T）
{
t1=*this;
t2=T;
flag=0;
}
else
{
t1=T;
t2=*this;
flag=1;
}
big=t1.len;
for（i=0;i{
if（t1.a[i]{
j=i+1;
while（t1.a[j]==0）
j++;
t1.a[j--]--;
while（j>i）
t1.a[j--]+=MAXN;
t1.a[i]+=MAXN+1-t2.a[i];
}
else
t1.a[i]-=t2.a[i];
}
t1.len=big;
while（t1.a[len-1]==0&&t1.len>1）
{
t1.len--;
big--;
}
if（flag）
t1.a[big-1]=0-t1.a[big-1];
returnt1;
}
BigNumBigNum:
:
operator*（constBigNum&T）const//两个大数之间的相乘运算
{
BigNumret;
inti,j,up;
inttemp,temp1;
for（i=0;i{
up=0;
for（j=0;j{
temp=a[i]*T.a[j]+ret.a[i+j]+up;
if（temp>MAXN）
{
temp1=temp-temp/（MAXN+1）*（MAXN+1）;
up=temp/（MAXN+1）;
ret.a[i+j]=temp1;
}
else
{
up=0;
ret.a[i+j]=temp;
}
}
if（up!
=0）
ret.a[i+j]=up;
}
ret.len=i+j;
while（ret.a[ret.len-1]==0&&ret.len>1）
ret.len--;
returnret;
}
BigNumBigNum:
:
operator/（constint&b）const//大数对一个整数进行相除运算
{
BigNumret;
inti,down=0;
for（i=len-1;i>=0;i--）
{
ret.a[i]=（a[i]+down*（MAXN+1））/b;
down=a[i]+down*（MAXN+1）-ret.a[i]*b;
}
ret.len=len;
while（ret.a[ret.len-1]==0&&ret.len>1）
ret.len--;
returnret;
}
intBigNum:
:
operator%（constint&b）const//大数对一个int类型的变量进行取模运算
{
inti,d=0;
for（i=len-1;i>=0;i--）
{
d=（（d*（MAXN+1））%b+a[i]）%b;
}
returnd;
}
BigNumBigNum:
:
operator^（constint&n）const//大数的n次方运算
{
BigNumt,ret
（1）;
inti;
if（n<0）
exit（-1）;
if（n==0）
return1;
if（n==1）
return*this;
intm=n;
while（m>1）
{
t=*this;
for（i=1;i<<1<=m;i<<=1）
{
t=t*t;
}
m-=i;
ret=ret*t;
if（m==1）
ret=ret*（*this）;
}
returnret;
}
boolBigNum:
:
operator>（constBigNum&T）const//大数和另一个大数的大小比较
{
intln;
if（len>T.len）
returntrue;
elseif（len==T.len）
{
ln=len-1;
while（a[ln]==T.a[ln]&&ln>=0）
ln--;
if（ln>=0&&a[ln]>T.a[ln]）
returntrue;
else
returnfalse;
}
else
returnfalse;
}
boolBigNum:
:
operator>（constint&t）const//大数和一个int类型的变量的大小比较
{
BigNumb（t）;
return*this>b;
}
voidBigNum:
:
print（）//输出大数
{
inti;
cout<for（i=len-2;i>=0;i--）
{
cout.width（DLEN）;
cout.fill（'0'）;
cout<}
cout<}
intmain（void）
{
while（true）
{
system（"cls"）;
BigNuma,b,c;
stringsa,sb;
cout<<"输入两个整数，以空格分开，回车确定：
";
cin>>sa>>sb;
a=sa;
b=sb;
intflag=0;
do
{
cout<<"1、相加\n2、相减\n3、相乘\n输入序号确定操作，非以上序号时退出\n"<cin>>flag;
switch（flag）
{
case1:
c=a+b;
break;
case2:
c=a-b;
break;
case3:
c=a*b;
break;
de
升级会员 