c++实现任意长整数的四则运算.docx

c++实现任意长整数的四则运算.docx

《c++实现任意长整数的四则运算.docx》由会员分享，可在线阅读，更多相关《c++实现任意长整数的四则运算.docx（17页珍藏版）》请在冰豆网上搜索。

c++实现任意长整数的四则运算

实验题目：

设计一数据结构可处理任意长度的整数

概要设计

1.数据结构的定义

采用双向链表存储任意长整数。

双向链表的定义如下：

classDblList{

private:

DblNode*head,*tail;

DblNode*current;

intsign;

public:

DblList（）;//构造函数

~DblList（）;//析构函数

boolCreatList（string）;//生成一个双向链表，存储整数

intGetCount（）;//获取整数的长度

voidInsert（DblNode*）;//从表尾插入一个结点

voidInsertFront（DblNode*）;//从表头插入

voidClear（）;//清除该链表

voidoperator+（DblList&）;//实现两个任意整数的加法

voidoperator*（DblList&）;//实现两个任意整数的乘法

DblList&operator=（DblList&）;//重载赋值运算符

intCompare（DblList&）;//两个整数的绝对值比较

voidDisplay（）;//任意长度整数的标准化输出

};

说明:

数据的存储，无外乎顺序或者链表。

顺序存储时，定义数组无法实现任意长度，而且需要预设一个maxsize，不是特别的方便。

所以采用链式存储方式。

而且任意长数据通过字符串输入。

在链表的每一个结点中，数据域是在该数位上的数字大小。

2．主要功能模块的功能

◆任意长整数的输入

◆任意长整数的标准化输出

◆两个整数的加法

◆两个整数的乘法

三．详细设计（主模块流程图）

5、使用说明及测试结果

1.使用说明：

点击打开应用程序pro1.exe。

依次输入任意两个整数（例如123456，+1234567），按回车，会出现菜单，如下图：

按‘1’则实现两整数的加法

按‘2’则实现两整数的乘法

按‘#’结束

注：

菜单可重复出现直至‘#’退出。

实现加法，乘法如下图：

2.测试结果：

（1）123456

（2）+1234567

（3）-987654321

（4）12a3

（5）+

注：

当输入错误时，允许重新输入。

6、源程序

/*主函数*/

/***************************************************/

#include"cal.h"

voidmain（）{

strings;

stringp;

DblListlist1;

while

（1）{//输入错误时，允许重新输入

cout<<"Inputnum1"<

cin>>s;

boolok1=list1.CreatList（s）;

if（!

ok1）

{

cout<<"error!

"<

}

else{

cout<<"num1:

";

list1.Display（）;

break;

}

}

DblListlist2;

while

（1）{

cout<<"Inputnum2:

"<

cin>>p;

boolok2=list2.CreatList（p）;

if（!

ok2）

{

cout<<"error!

"<

}

else{

cout<<"num2:

";

list2.Display（）;

break;

}

}

stringchoose;

while

（1）

{

cout<<"请选择运算法：

"<

cout<<"--------------------------"<

cout<<"|1.num1+num2|"<

cout<<"|2.num1*num2|"<

cout<<"|#.exit|"<

cout<<"--------------------------"<

while

（1）

{

cin>>choose;

if（choose=="1"）

{

list1+list2;

break;

}

elseif（choose=="2"）

{

list1*list2;

break;

}

elseif（choose=="#"）

{

return;

}

else

{

cout<<"输入有误，请重新输入！

！

"<

continue;

}

}

}

}

/*头文件，包括长整数数据结构的定义，成员函数的定义*/

/***********************************************************/

#include

#include

#include

usingnamespacestd;

structDblNode{

intdata;

DblNode*prior;

DblNode*next;

};

boolIsNum（chara）{//判断字符a是否是便是数字

ints=a-'0';

if（s>=0&&s<10）returntrue;

elsereturnfalse;

}

boolIsInt（stringa）{//判断字符串a是否表达一串数字

boolJud=1;

inti=1;

chars=a[0];

if（a=="+"||a=="-"）returnfalse;

if（s=='+'||s=='-'）{}

elseif（s>='1'&&s<='9'）{}

elseif（a[0]=='0'&&a[1]=='\0'）returntrue;

elsereturnfalse;

while（a[i]!

='\0'）

{

Jud=IsNum（a[i]）;

if（Jud==0）returnfalse;

i++;

}

returntrue;

}

intJudSign（strings）{//返回数字的符号

if（s[0]=='-'）return-1;

elseif（s[0]=='0'&&s[1]=='\0'）return0;

elsereturn1;

}

intCtoI（chara）{

inti=a-'0';

returni;

}

classDblList{//定义一个双向链表类，存储任意长度的数字

private:

//并可以进行标准化输出和加法，乘法。

DblNode*head,*tail;

DblNode*current;

intsign;

public:

DblList（）;//构造函数

~DblList（）;//析构函数

boolCreatList（string）;//生成一个双向链表

intGetCount（）;//获取整数的长度

voidInsert（DblNode*）;//从表尾插入一个结点

voidInsertFront（DblNode*）;//从表头插入一个结点

voidClear（）;//清除该链表

voidoperator+（DblList&）;//实现两个任意整数的加法

voidoperator*（DblList&）;//实现两个任意整数的乘法

DblList&operator=（DblList&）;//重载赋值运算符

intCompare（DblList&）;//两个整数的绝对值比较

voidDisplay（）;//任意长度整数的标准化输出

};

DblList:

:

DblList（）{

head=newDblNode（）;//构造函数

head->next=NULL;

head->prior=NULL;

tail=head;

current=NULL;

sign=0;

}

DblList:

:

~DblList（）{//析构函数

while（head->next!

=NULL）

{

current=head->next;

head->next=current->next;

deletecurrent;

}

current=NULL;

sign=0;

deletehead;

head=NULL;

tail=NULL;

}

intDblList:

:

GetCount（）{//返回该数字的长度（不包括符号位）

current=head->next;

intcount=0;

while（current）

{

count++;

current=current->next;

}

current=NULL;

returncount;

}

voidDblList:

:

Insert（DblNode*p）{//从链表尾部插入一个结点

tail->next=p;

p->prior=tail;

tail=p;

}

voidDblList:

:

InsertFront（DblNode*q）{//从链表头部插入一个结点

if（head->next==NULL）

{

head->next=q;

q->prior=head;

tail=q;

}

else{

q->next=head->next;

head->next->prior=q;

head->next=q;

q->prior=head;

}

}

boolDblList:

:

CreatList（strings）{//输入的任意长度的表示数字的字符串

boolj=IsInt（s）;//以此生成双向链表

if（!

j）returnj;

else{

inti=0;

sign=JudSign（s）;

if（s[0]=='+'||s[0]=='-'）i++;

while（s[i]!

='\0'）

{

intia=CtoI（s[i]）;

current=newDblNode（）;

current->data=ia;

current->next=NULL;

current->prior=NULL;

Insert（current）;

i++;

current=NULL;

}

returntrue;

}

}

voidDblList:

:

Clear（）{

while（head->next）

{

current=head->next;

head->next=current->next;

deletecurrent;

}

tail=head;

sign=0;

current=NULL;

}

intDblList:

:

Compare（DblList&s）{//任意两个长度数字绝对值比较

inta=GetCount（）;

intb=s.GetCount（）;

if（a>b）return1;

elseif（a

else

{

current=head->next;

s.current=s.head->next;

while（current!

=NULL）

{

intre=current->data-s.current->data;

if（re>0）return1;

elseif（re<0）return-1;

else

{

current=current->next;

s.current=s.current->next;

}

}

current=NULL;

s.current=NULL;

return0;

}

}

DblList&DblList:

:

operator=（DblList&s）{

Clear（）;

sign=s.sign;

s.current=s.head->next;

while（s.current!

=NULL）

{

current=newDblNode（）;

current->data=s.current->data;

Insert（current）;

s.current=s.current->next;

}

s.current=NULL;

current=NULL;

return*this;

}

voidDblList:

:

operator+（DblList&s）{//实现加法（包括减法）

DblListtemp;

intda;

intf=0;

intsi=Compare（s）;

if（si==0&&（sign+s.sign==0））temp.sign=0;

else

{

if（si==0）temp.sign=sign;

elseif（si>0）temp.sign=sign;

elsetemp.sign=s.sign;

current=tail;

s.current=s.tail;

while

（1）

{

if（current==head&&s.current==s.head）

{

if（f）

{

da=f;

temp.current=newDblNode（）;

temp.current->data=f;

temp.InsertFront（temp.current）;

}

if（!

f）break;

f=0;

}

elseif（current!

=head&&s.current==s.head）

{

temp.current=newDblNode（）;

temp.current->data=current->data+f;

temp.InsertFront（temp.current）;

current=current->prior;

f=0;

}

elseif（current==head&&s.current!

=s.head）

{

temp.current=newDblNode（）;

temp.current->data=s.current->data+f;

temp.InsertFront（temp.current）;

s.current=s.current->prior;

f=0;

}

else{

da=current->data*sign+s.current->data*s.sign+f;

if（da*temp.sign>=10）

{

da=da-10*temp.sign;

f=temp.sign;

}

elseif（da*temp.sign<0）

{

da=da+10*temp.sign;

f=-temp.sign;

}

elsef=0;

temp.current=newDblNode（）;

temp.current->next=NULL;

temp.current->data=abs（da）;

temp.InsertFront（temp.current）;

current=current->prior;

s.current=s.current->prior;

}

}

current=NULL;

s.current=NULL;

}

temp.current=temp.head->next;

if（temp.current!

=NULL）

while（temp.current->data==0）

{

temp.head->next=temp.current->next;

deletetemp.current;

temp.current=temp.head->next;

}

temp.current=NULL;

cout<<"num1+num2=";

temp.Display（）;

}

voidDblList:

:

operator*（DblList&s）{//实现乘法

intcf=0;

intans;

inti,j;

intcount=0;

DblListtemp;

temp.sign=sign*s.sign;

inta1=GetCount（）;

inta2=s.GetCount（）;

inta=a1+a2;

for（i=0;i

{

temp.current=newDblNode（）;

temp.current->data=0;

temp.current->next=NULL;

temp.current->prior=NULL;

temp.InsertFront（temp.current）;

}

s.current=s.tail;

while（s.current!

=s.head）{

current=tail;

temp.current=temp.tail;

for（i=0;iprior;

for（j=0;j

ans=s.current->data*current->data+temp.current->data+cf;

temp.current->data=ans%10;

cf=ans/10;

current=current->prior;

temp.current=temp.current->prior;

}

if（cf!

=0）

{

temp.current->data=temp.current->data+cf;

cf=0;

}

s.current=s.current->prior;

temp.current=temp.tail;

count++;

}

if（temp.head->next->data==0）

{

temp.current=temp.head->next;

temp.head->next=temp.current->next;

deletetemp.current;

temp.current=NULL;

}

cout<<"num1*num2=";

temp.Display（）;

}

voidDblList:

:

Display（）{//任意长数字的标准化输出

intcount=GetCount（）;

if（sign==0）

{

cout<<"0"<

return;

}

elseif（sign==-1）cout<<"-";

current=head->next;

while（current!

=NULL）

{

if（count>0）{

cout<data;

count--;

if（count%3==0&&count!

=0）cout<<",";

current=current->next;

}

}

current=NULL;

cout<

cout<<"--------------------------------------------------------------"<

}