巨型整数运算 -- 编程爱好者潇潇枫-- 编程爱好者博客

大二上学期程序设计实践课的题目: 编写一个巨型整数类(类名统一规定为：HugeInt)，可以用默认值0或长整型数或字符串进行对象的初始化(构造)然后用成员、友元或普通函数等重载相应的运算符实现下述功能(必须优化算法、同时进行异常处理)：“巨型整数”OP“巨型整数/长整型数/字符串” [其中OP为：加+、减-、乘*、整除/、求余%、复合运算(+=、-=、*=、/=、%=)和关系运算(>、>=、<、<=、!=和==)]“长整型数/字符串”OP “巨型整数”(其中OP为：+、-、*、/、%和关系运算)，求负(-巨型整数)，巨型整数++、++巨型整数，--巨型整数、巨型整数--，插入(输出)运算符<<。最后编写一个主函数(测试程序)对以上功能进行全面的测试。必须选Win32 Console Application (控制台应用)实现。 !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 本程序为初期完成,有点BUG:如1000位与1000位相乘时速度不快! 待改进,用字符串速度速度很明显加快! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! **********备注：(本程序采用的*双端队列*的数据结构构造巨型整数) ********** **************************** ^^__^^构造函数^^__^^ ****************************本程序巨型整数可以用默认值0或长整型数或字符串进行对象的初始化,为方便计算,程序将自动对输入的整数加上相应符号(如输入123,自动处理为+123,只输入+或-或-0或0将自动处理为+0,若为-123则不修改!) ***** 如输入字符"0123",本程序不自动处理,而将其抛出异常!输入* 除巨型整数第一位可以为字符+或-外,其他字符在0-9外(不包括0和9)都将抛出异常! 限制* 进行除法运算时,被除数是0时将抛出异常,由于取余运算调用除法,所以对0取余也将抛出异常! 在主函数中因除0异常已在除法中处理,所以在取余中省去!***** *********输出说明: 巨型整数的第一个字符表示整数的正负属性,+0表示0,+X表示正数,-X表示负数!********* ***********************************************************************(本程序主要运算符重载的算法,包括:加法,减法,乘法,除法,取余,开平方)***********************************************************************(本程序加法和减法都只写了同符号之间的运算,符号不同的再互相调用)①巨型整数加法算法：(1)删除符号位,计算出两个巨型整数长度.(2)从最后一位开始转化为整型相加并加上进位,直到长度较小整数的第一位相加结束.(3)处理长度较大的数的高位加上长度较小的数的最高位进位后进位情况,无进位则不处理.(4)如果长度较大的最高位有进位则必须增加一位最高位1(例如999+1=1000).(5)根据符号标志为最终结果加上相应的符号(+或-).(6)符号不同的再调用减法进行计算. ②巨型整数减法算法：(1)计算两个巨型整数的绝对值.(2)删除符号位,用绝对值较大的数为被减数,绝对值较小的数为减数.(3)从最后一位开始转化为整型相减并减去退位,直到绝对值较小的整数第一位相减结束.(4)处理绝对值较大的数的高位减去绝对值较小的数的最高位有退位的退位情况,无退位则不处理.(5)处理相减完高位上存在的累赘0 (如+00001,结果必须是+1).(6)根据符号标志为最终结果加上相应的符号(+或-).(7)符号不同的再调用加法进行计算. ③巨型整数乘法算法：(使用迭加算法,调用巨型整数加法运算)(1)删除符号位,计算出两个巨型整数长度.(2)从长度较小的整数最后一位开始把长度较大的整数迭加,迭加次数为其转化为整型后的值. (例如123*24,第一次把123迭加4次存放到相应空间中如(p[0]中),再把123迭加2次后放入另一空间中如(p[1])中).(3)为每个迭加后的数(不包括+0)乘上相应的10^m(10的m次方).(例如上面的123*24,迭加完以后,p[0]中的值要乘以10的0次方,p[1]中的值要乘以10的1次方).(4)把每个存放的值相加得到结果.(5)根据符号标志为最张结果加上相应的符号(+或-). ④巨型整数除以大整数主要有三种方法：1. 试商法2. 相减法，即由被除数不断地减去除数来得到3. 化除为乘。先把被除数取倒数，然后让倒数与除数相乘。取倒数可以使用牛顿迭代法。。（速度最快）-----------------------本程序的除法采用试商法-----------------------(1)从被除数的最高位起，先用除数(假如有n位符号不算)试除被除数的前n位，如果它比除数小，再试除前n+1位。(2)除到被除数的哪一位，商就写在哪一位的上面(哪一位不够商1，写0)。(3)每次除后余下的数必须比除数小。(4)每次除后余下的数与右边一位数组成下一个被除数(记为过程被除数)。(5)用同样的方法，继续求平方根的其他各位上的数。附:处理除数为0异常! ⑤巨型整数取余算法:(调用巨型整数的乘法和除法运算)设两个巨型整数分别为h1,h2;取余结果为h3.使用公式h3=h1-((h1/h2)*h2); --------------------⑥本程序附加了对非负巨型整数开平方,其算法为(采用初中二年级代数书上的算法)： --------------------(1)将被开方数的整数部分从个位起向左每隔两位划为一段，用撇号分开，分成几段，表示所求平方根是几位数.(2)根据左边第一段里的数，求得平方根的最高位上的数.(3)从第一段的数减去最高位上数的平方，在它们的差的右边写上第二段数组成第一个余数.(4)把求得的最高位数乘以20去试除第一个余数，所得的最大整数作为试商.(5)用商的最高位数的20倍加上这个试商再乘以试商．如果所得的积小于或等于余数，试商就是平方根的第二位数;如果所得的积大于余数，就把试商减小再试.(6)用同样的方法，继续求平方根的其他各位上的数． \*----------------------------------------------------------------------------------------------*/ #include<iostream>#include<cstring>#include<deque>#include<cmath>#include <conio.h> //getch原型using namespace std; //普通函数声明int c_to_i(char c);//将字符型转化为整型char i_to_c(int a);//将整型转化为字符型 //前项引用声明----------------------------------------------------------------------------------class HugeInt;ostream &operator<<(ostream &out,HugeInt &a);//重载输出<<istream &operator>>(istream &in,HugeInt &a); //重载输入>> bool operator == (const HugeInt &h1,const HugeInt &h2); //重载巨型整数==巨型整数bool operator == (const HugeInt &h1,char *a); //重载巨型整数==字符串bool operator == (char *a,const HugeInt &h1); //重载字符串==巨型整数bool operator == (const HugeInt &h1,long a); //重载巨型整数==长整数bool operator == (long a,const HugeInt &h1); //重载长整数==巨型整数 bool operator != (const HugeInt &h1,const HugeInt &h2); //重载巨型整数!=巨型整数bool operator != (const HugeInt &h1,char *a); //重载巨型整数!=字符串bool operator != (char *a,const HugeInt &h1); //重载字符串!=巨型整数bool operator != (const HugeInt &h1,long a); //重载巨型整数!=长整数bool operator != (long a,const HugeInt &h1); //重载长整数!=巨型整数 bool operator > (const HugeInt &h1,const HugeInt &h2); //重载巨型整数>巨型整数bool operator > (const HugeInt &h1,char *a); //重载巨型整数>字符串bool operator > (char *a,const HugeInt &h1); //重载字符串>巨型整数bool operator > (const HugeInt &h1,long a); //重载巨型整数>长整数bool operator > (long a,const HugeInt &h1); //重载长整数>巨型整数 bool operator >= (const HugeInt &h1,const HugeInt &h2); //重载巨型整数>=巨型整数bool operator >= (const HugeInt &h1,char *a); //重载巨型整数>=字符串bool operator >= (char *a,const HugeInt &h1); //重载字符串>=巨型整数bool operator >= (const HugeInt &h1,long a); //重载巨型整数>=长整数bool operator >= (long a,const HugeInt &h1); //重载长整数>=巨型整数 bool operator < (const HugeInt &h1,const HugeInt &h2); //重载巨型整数<巨型整数bool operator < (const HugeInt &h1,char *a); //重载巨型整数<字符串bool operator < (char *a,const HugeInt &h1); //重载字符串<巨型整数bool operator < (const HugeInt &h1,long a); //重载巨型整数<长整数bool operator < (long a,const HugeInt &h1); //重载长整数<巨型整数 bool operator <= (const HugeInt &h1,const HugeInt &h2); //重载巨型整数<=巨型整数bool operator <= (const HugeInt &h1,char *a); //重载巨型整数<=字符串bool operator <= (char *a,const HugeInt &h1); //重载字符串<=巨型整数bool operator <= (const HugeInt &h1,long a); //重载巨型整数<=长整数bool operator <= (long a,const HugeInt &h1); //重载长整数<=巨型整数 HugeInt operator + (HugeInt h1,HugeInt h2); //重载巨型整数+巨型整数HugeInt operator + (HugeInt h1,char *a); //重载巨型整数+字符串HugeInt operator + (char *a,HugeInt h1); //重载字符串+巨型整数HugeInt operator + (HugeInt h1,long a); //重载巨型整数+长整数HugeInt operator + (long a,HugeInt h1); //重载长整数+巨型整数 HugeInt operator - (HugeInt h1,HugeInt h2); //重载巨型整数-巨型整数HugeInt operator - (HugeInt h1,char *a); //重载巨型整数-字符串HugeInt operator - (char *a,HugeInt h1); //重载字符串-巨型整数HugeInt operator - (HugeInt h1,long a); //重载巨型整数-长整数HugeInt operator - (long a,HugeInt h1); //重载长整数-巨型整数 HugeInt operator * (HugeInt h1,HugeInt h2); //重载巨型整数*巨型整数HugeInt operator * (HugeInt h1,char *a); //重载巨型整数*字符串HugeInt operator * (char *a,HugeInt h1); //重载字符串*巨型整数HugeInt operator * (HugeInt h1,long a); //重载巨型整数*长整数HugeInt operator * (long a,HugeInt h1); //重载长整数*巨型整数 HugeInt quotient (HugeInt h1,HugeInt h2); //用于除法中的商值函数HugeInt diff (HugeInt h1,HugeInt h2); //用于除法中的差值函数 HugeInt operator / (HugeInt h1,HugeInt h2); //重载巨型整数/巨型整数HugeInt operator / (HugeInt h1,char *a); //重载巨型整数/字符串HugeInt operator / (char *a,HugeInt h1); //重载字符串/巨型整数HugeInt operator / (HugeInt h1,long a); //重载巨型整数/长整数HugeInt operator / (long a,HugeInt h1); //重载长整数/巨型整数 HugeInt operator % (HugeInt h1,HugeInt h2); //重载巨型整数%巨型整数HugeInt operator % (HugeInt h1,char *a); //重载巨型整数%字符串HugeInt operator % (char *a,HugeInt h1); //重载字符串%巨型整数HugeInt operator % (HugeInt h1,long a); //重载巨型整数%长整数HugeInt operator % (long a,HugeInt h1); //重载长整数%巨型整数 HugeInt sqrt_quot (HugeInt h1,HugeInt h2); //开平方运算中求商值函数HugeInt sqrt_diff (HugeInt h1,HugeInt h2); //开平方运算中求差值函数HugeInt quot (HugeInt h); //开平方运算中求出初始试商HugeInt sqrt (HugeInt h); //对巨型整数进行开平方//----------------------------------------------------------------------------------------------*/ class Illegal{}; //定义输入异常class wrong_deno{}; //定义分母异常 //**************************************类定义开始*********************************************//class HugeInt{//定义巨型整数类public: HugeInt(){hugeint.push_back('+');hugeint.push_back('0');}; //无参构造函数,默认值为+0 HugeInt(char *a); //有参构造函数(用字符串进行初始化) HugeInt(long a); //有参构造函数(用长整型数进行初始化) void set_hugeint(char *a); //修改巨型整数的值(用字符串进行修改) void set_hugeint(long a); //修改巨型整数的值(用长整型数进行修改) HugeInt(const HugeInt &h); //拷贝构造函数 HugeInt abs(HugeInt h); //对巨型整数取绝对值 HugeInt operator = (const HugeInt &h); //重载巨型整数赋值 HugeInt operator - (); //重载巨型整数取负 HugeInt operator += (HugeInt h); //重载巨型整数+=巨型整数 HugeInt operator += (char *a); //重载巨型整数+=字符串 HugeInt operator += (long a); //重载巨型整数+=长整数 HugeInt operator -= (HugeInt h); //重载巨型整数-=巨型整数 HugeInt operator -= (char *a); //重载巨型整数-=字符串 HugeInt operator -= (long a); //重载巨型整数-=长整数 HugeInt operator *= (HugeInt h); //重载巨型整数*=巨型整数 HugeInt operator *= (char *a); //重载巨型整数*=字符串 HugeInt operator *= (long a); //重载巨型整数*=长整数 HugeInt operator /= (HugeInt h); //重载巨型整数/=巨型整数 HugeInt operator /= (char *a); //重载巨型整数/=字符串 HugeInt operator /= (long a); //重载巨型整数/=长整数 HugeInt operator %= (HugeInt h); //重载巨型整数%=巨型整数 HugeInt operator %= (char *a); //重载巨型整数%=字符串 HugeInt operator %= (long a); //重载巨型整数%=长整数 HugeInt operator ++ (int p); //重载巨型整数++ HugeInt operator ++ (); //重载++巨型整数 HugeInt operator -- (int p); //重载巨型整数-- HugeInt operator -- (); //重载--巨型整数 friend ostream &operator<<(ostream &out,HugeInt &a);//重载输出<< friend istream &operator>>(istream &in,HugeInt &a); //重载输入>> friend bool operator == (const HugeInt &h1,const HugeInt &h2); //重载巨型整数==巨型整数 friend bool operator == (const HugeInt &h1,char *a); //重载巨型整数==字符串 friend bool operator == (char *a,const HugeInt &h1); //重载字符串==巨型整数 friend bool operator == (const HugeInt &h1,long a); //重载巨型整数==长整数 friend bool operator == (long a,const HugeInt &h1); //重载长整数==巨型整数 friend bool operator != (const HugeInt &h1,const HugeInt &h2); //重载巨型整数!=巨型整数 friend bool operator != (const HugeInt &h1,char *a); //重载巨型整数!=字符串 friend bool operator != (char *a,const HugeInt &h1); //重载字符串!=巨型整数 friend bool operator != (const HugeInt &h1,long a); //重载巨型整数!=长整数 friend bool operator != (long a,const HugeInt &h1); //重载长整数!=巨型整数 friend bool operator > (const HugeInt &h1,const HugeInt &h2); //重载巨型整数>巨型整数 friend bool operator > (const HugeInt &h1,char *a); //重载巨型整数>字符串 friend bool operator > (char *a,const HugeInt &h1); //重载字符串>巨型整数 friend bool operator > (const HugeInt &h1,long a); //重载巨型整数>长整数 friend bool operator > (long a,const HugeInt &h1); //重载长整数>巨型整数 friend bool operator >= (const HugeInt &h1,const HugeInt &h2); //重载巨型整数>=巨型整数 friend bool operator >= (const HugeInt &h1,char *a); //重载巨型整数>=字符串 friend bool operator >= (char *a,const HugeInt &h1); //重载字符串>=巨型整数 friend bool operator >= (const HugeInt &h1,long a); //重载巨型整数>=长整数 friend bool operator >= (long a,const HugeInt &h1); //重载长整数>=巨型整数 friend bool operator < (const HugeInt &h1,const HugeInt &h2); //重载巨型整数<巨型整数 friend bool operator < (const HugeInt &h1,char *a); //重载巨型整数<字符串 friend bool operator < (char *a,const HugeInt &h1); //重载字符串<巨型整数 friend bool operator < (const HugeInt &h1,long a); //重载巨型整数<长整数 friend bool operator < (long a,const HugeInt &h1); //重载长整数<巨型整数 friend bool operator <= (const HugeInt &h1,const HugeInt &h2); //重载巨型整数<=巨型整数 friend bool operator <= (const HugeInt &h1,char *a); //重载巨型整数<=字符串 friend bool operator <= (char *a,const HugeInt &h1); //重载字符串<=巨型整数 friend bool operator <= (const HugeInt &h1,long a); //重载巨型整数<=长整数 friend bool operator <= (long a,const HugeInt &h1); //重载长整数<=巨型整数 friend HugeInt operator + (HugeInt h1,HugeInt h2); //重载巨型整数+巨型整数 friend HugeInt operator + (HugeInt h1,char *a); //重载巨型整数+字符串 friend HugeInt operator + (char *a,HugeInt h1); //重载字符串+巨型整数 friend HugeInt operator + (HugeInt h1,long a); //重载巨型整数+长整数 friend HugeInt operator + (long a,HugeInt h1); //重载长整数+巨型整数 friend HugeInt operator - (HugeInt h1,HugeInt h2); //重载巨型整数-巨型整数 friend HugeInt operator - (HugeInt h1,char *a); //重载巨型整数-字符串 friend HugeInt operator - (char *a,HugeInt h1); //重载字符串-巨型整数 friend HugeInt operator - (HugeInt h1,long a); //重载巨型整数-长整数 friend HugeInt operator - (long a,HugeInt h1); //重载长整数-巨型整数 friend HugeInt operator * (HugeInt h1,HugeInt h2); //重载巨型整数*巨型整数 friend HugeInt operator * (HugeInt h1,char *a); //重载巨型整数*字符串 friend HugeInt operator * (char *a,HugeInt h1); //重载字符串*巨型整数 friend HugeInt operator * (HugeInt h1,long a); //重载巨型整数*长整数 friend HugeInt operator * (long a,HugeInt h1); //重载长整数*巨型整数 friend HugeInt quotient (HugeInt h1,HugeInt h2); //用于除法中的商值函数 friend HugeInt diff (HugeInt h1,HugeInt h2); //用于除法中的差值函数 friend HugeInt operator / (HugeInt h1,HugeInt h2); //重载巨型整数/巨型整数 friend HugeInt operator / (HugeInt h1,char *a); //重载巨型整数/字符串 friend HugeInt operator / (char *a,HugeInt h1); //重载字符串/巨型整数 friend HugeInt operator / (HugeInt h1,long a); //重载巨型整数/长整数 friend HugeInt operator / (long a,HugeInt h1); //重载长整数/巨型整数 friend HugeInt operator % (HugeInt h1,HugeInt h2); //重载巨型整数%巨型整数 friend HugeInt operator % (HugeInt h1,char *a); //重载巨型整数%字符串 friend HugeInt operator % (char *a,HugeInt h1); //重载字符串%巨型整数 friend HugeInt operator % (HugeInt h1,long a); //重载巨型整数%长整数 friend HugeInt operator % (long a,HugeInt h1); //重载长整数%巨型整数 friend HugeInt sqrt_quot (HugeInt h1,HugeInt h2); //开平方运算中求商值函数 friend HugeInt sqrt_diff (HugeInt h1,HugeInt h2); //开平方运算中求差值函数 friend HugeInt quot (HugeInt h); //开平方运算中求出初始试商 friend HugeInt sqrt (HugeInt h); //对巨型整数进行开平方private: //使用双端队列构造巨型整数 deque<char> hugeint;}; //**************************************类定义结束**********************************************// //-------------------------------------类成员函数实现开始---------------------------------------//HugeInt::HugeInt(char *a){//有参构造函数(用字符串进行初始化) //第一个字符的合法输入必须是在1-9之间或是+、-,(如果是0,则整个字符串长度只能为1,即传入的字符串只含有一个0时为合法) if((a[0]<48||a[0]>57||(a[0]=='0'&&strlen(a)!=1))&&a[0]!='-'&&a[0]!='+')throw Illegal(); if((a[0]=='+'||a[0]=='-')&&a[1]=='0'&&strlen(a)!=2)throw Illegal(); //第二个字符开始只能含有0-9之间的字符 for(int i=1;i<strlen(a);i++) if(a[i]<48||a[i]>57)throw Illegal(); hugeint.resize(strlen(a)); //将字符串转化为双端队列 for(int j=0;j<hugeint.size();j++) hugeint[j]=a[j]; //如果第一个字符不是负号且不是正号,即全体非负数在前面加上一个'+'号 if(hugeint[0]!='-'&&hugeint[0]!='+')hugeint.push_front('+'); //如果输入的是-0,则把其改为+0 if(hugeint[0]=='-'&&hugeint[1]=='0')hugeint[0]='+'; //如果只输入一个字符(+或-)时,自动转化成+0 if(hugeint.size()==1&&(hugeint[0]=='+'||hugeint[0]=='-')) { hugeint[0]='+'; hugeint.push_back('0'); }} HugeInt::HugeInt(long a){//有参构造函数(用长整型数进行初始化) int flag=0; //定义标志,用来记录处理的数的符号,默认负数为0 if(a>=0)flag=1; //标记输入的长整数是非负数,前面须加上'+'号 if(a==0)hugeint.push_back('0'); a=fabs(a); //输入的长整数全部用绝对值进行计算,最后再判断最前面应加上'-'号或'+'号 for(int temp=0;a!=0;) {//把长整数转化为字符串放入双端队列中 /*具体算法:先对10取余再除以10,再循环以上两步,直到长整数为0,即转化结束*/ temp=a%10; hugeint.push_front(char(temp+48)); a/=10; } //对输入的长整数的符号进行判断 if(flag)hugeint.push_front('+'); else hugeint.push_front('-');} void HugeInt::set_hugeint(char *a){//修改巨型整数的值(用字符串进行修改) hugeint.clear(); //清除队列中原有的数值,以免影响结果 //第一个字符的合法输入必须是在1-9之间或是+、-,(如果是0,则整个字符串长度只能为1,即传入的字符串只含有一个0时为合法) if((a[0]<48||a[0]>57||(a[0]=='0'&&strlen(a)!=1))&&a[0]!='-'&&a[0]!='+')throw Illegal(); if((a[0]=='+'||a[0]=='-')&&a[1]=='0'&&strlen(a)!=2)throw Illegal(); //第二个字符开始只能含有0-9之间的字符 for(int i=1;i<strlen(a);i++) if(a[i]<48||a[i]>57)throw Illegal(); hugeint.resize(strlen(a)); //将字符串转化为双端队列 for(int j=0;j<hugeint.size();j++) hugeint[j]=a[j]; //如果第一个字符不是负号且不是正号,即全体非负数在前面加上一个'+'号 if(hugeint[0]!='-'&&hugeint[0]!='+')hugeint.push_front('+'); //如果输入的是-0,则把其改为+0 if(hugeint[0]=='-'&&hugeint[1]=='0')hugeint[0]='+'; //如果只输入一个字符(+或-)时,自动转化成+0 if(hugeint.size()==1&&(hugeint[0]=='+'||hugeint[0]=='-')) { hugeint[0]='+'; hugeint.push_back('0'); }} void HugeInt::set_hugeint(long a){//修改巨型整数的值(用长整型数进行修改) hugeint.clear(); //清除队列中原有的数值,以免影响结果 int flag=0; //定义标志,用来记录处理的数的符号,默认负数为0 if(a>=0)flag=1; //标记输入的长整数是非负数,前面须加上'+'号 a=fabs(a); //输入的长整数全部用绝对值进行计算,最后再判断最前面应加上'-'号或'+'号 for(int temp=0;a!=0;) {//把长整数转化为字符串放入双端队列中 /*具体算法:先对10取余再除以10,再循环以上两步,直到长整数为0,即转化结束*/ temp=a%10; hugeint.push_front(char(temp+48)); a/=10; } //对输入的长整数的符号进行判断 if(flag)hugeint.push_front('+'); else hugeint.push_front('-');} HugeInt::HugeInt(const HugeInt &h){//拷贝构造函数 //把巨型整数中的所有值按顺序存入 for(int i=0;i<h.hugeint.size();i++) hugeint.push_back(h.hugeint[i]);} HugeInt HugeInt::abs(HugeInt h){//对巨型整数取绝对值 h.hugeint[0]='+'; return h;} HugeInt HugeInt::operator = (const HugeInt &h){//重载巨型整数赋值 //清除内部的值,以免影响结果 (*this).hugeint.clear(); //把巨型整数中的所有值按顺序存入 for(int i=0;i<h.hugeint.size();i++) hugeint.push_back(h.hugeint[i]); return *this;} HugeInt HugeInt::operator - (){//重载巨型整数取负 HugeInt h(*this); //处理正数情况,把正号改为负号 if(h.hugeint[0]=='+') { h.hugeint[0]='-'; //处理+0的情况,不改变符号 if((h.hugeint[0]=='+'||h.hugeint[0]=='-')&&h.hugeint[1]=='0')h.hugeint[0]='+'; //返回取负后的值 return h; } //处理负数情况,把负号改为正号 if(h.hugeint[0]=='-') { h.hugeint[0]='+'; //返回取负后的值 return h; } return h;} HugeInt HugeInt::operator += (HugeInt h){//重载巨型整数+=巨型整数 HugeInt h0(*this); *this=h0+h; return *this;} HugeInt HugeInt::operator += (char *a){//重载巨型整数+=字符串 HugeInt h0(*this),h(a); *this=h0+h; return *this;} HugeInt HugeInt::operator += (long a){//重载巨型整数+=长整数 HugeInt h0(*this),h(a); *this=h0+h; return *this;} HugeInt HugeInt::operator -= (HugeInt h){//重载巨型整数-=巨型整数 HugeInt h0(*this); *this=h0-h; return *this;} HugeInt HugeInt::operator -= (char *a){//重载巨型整数-=字符串 HugeInt h0(*this),h(a); *this=h0-h; return *this;} HugeInt HugeInt::operator -= (long a){//重载巨型整数-=长整数 HugeInt h0(*this),h(a); *this=h0-h; return *this;} HugeInt HugeInt::operator *= (HugeInt h){//重载巨型整数*=巨型整数 HugeInt h0(*this); *this=h0*h; return *this;} HugeInt HugeInt::operator *= (char *a){//重载巨型整数*=字符串 HugeInt h0(*this),h(a); *this=h0*h; return *this;} HugeInt HugeInt::operator *= (long a){//重载巨型整数*=长整数 HugeInt h0(*this),h(a); *this=h0*h; return *this;} HugeInt HugeInt::operator /= (HugeInt h){//重载巨型整数/=巨型整数 *this=*this/h; return *this;} HugeInt HugeInt::operator /= (char *a){//重载巨型整数/=字符串 HugeInt h(a); *this=*this/h; return *this;}HugeInt HugeInt::operator /= (long a){//重载巨型整数/=长整数 HugeInt h(a); *this=*this/h; return *this;} HugeInt HugeInt::operator %= (HugeInt h){//重载巨型整数%=巨型整数 *this=*this%h; return *this;} HugeInt HugeInt::operator %= (char *a){//重载巨型整数%=字符串 HugeInt h(a); *this=*this%h; return *this;}HugeInt HugeInt::operator %= (long a){//重载巨型整数%=长整数 HugeInt h(a); *this=*this%h; return *this;} HugeInt HugeInt::operator ++ (int p){//重载巨型整数++ HugeInt h(*this); *this=*this+1; return h;} HugeInt HugeInt::operator ++ (){//重载++巨型整数 *this=*this+1; return *this;} HugeInt HugeInt::operator -- (int p){//重载巨型整数-- HugeInt h(*this); *this=*this-1; return h;} HugeInt HugeInt::operator -- (){//重载++巨型整数 *this=*this-1; return *this;} //-------------------------------------类成员函数实现结束---------------------------------------// //-------------------------------------类友元函数实现开始---------------------------------------//ostream &operator<<(ostream &out,HugeInt &a){//重载输出<<(使用迭代器) deque<char>::iterator p; for(p=a.hugeint.begin();p!=a.hugeint.end();p++) out<<*p; out<<endl; return out;} istream &operator>>(istream &in,HugeInt &a){//重载输入>> a.hugeint.clear(); //清除队列中原有的值 char c; //定义取值中间变量 c=getchar(); //判断第一个字符的合法性 if((c<48||c>57)&&c!='-'&&c!='+'){a=0l;throw Illegal();} //将第一个字符送到队列中 a.hugeint.push_back(c); //继续输入字符,判断其合法性再将其送到队列中,直到回车为止 while((c=getchar())!='\n') { if(c<48||c>57){a=0l;throw Illegal();} a.hugeint.push_back(c); } //如果第一个是+或-,而第二个是0且总的长度不为2,即不为+0或-0时就抛出异常(例+012就不合法) if((a.hugeint[0]=='+'||a.hugeint[0]=='-')&&a.hugeint[1]=='0'&&a.hugeint.size()!=2){a=0l;throw Illegal();} //如果第一个为0且总的长度不为1就抛出异常 if(a.hugeint[0]=='0'&&a.hugeint.size()!=1){a=0l;throw Illegal();} //判断输入数字的符号并加上相应的数学符号 if(a.hugeint[0]!='-'&&a.hugeint[0]!='+')a.hugeint.push_front('+'); //如果输入的是-0,则把其改为+0 if(a.hugeint[0]=='-'&&a.hugeint[1]=='0')a.hugeint[0]='+'; //如果只输入一个字符(+或-)时,自动转化成+0 if(a.hugeint.size()==1&&(a.hugeint[0]=='+'||a.hugeint[0]=='-')) { a.hugeint[0]='+'; a.hugeint.push_back('0'); } return in;} bool operator == (const HugeInt &h1,const HugeInt &h2){//重载巨型整数==巨型整数 //如果两个数的长度不一样,肯定不相等 if(h1.hugeint.size()!=h2.hugeint.size())return false; //从高位依次比较字符是否相等,若不等,直接返回false for(int i=0;i<h1.hugeint.size();i++) if(h1.hugeint[i]!=h2.hugeint[i]) return false; //否则返回true return true;} bool operator == (const HugeInt &h1,char *a){ //重载巨型整数==字符串 HugeInt h2(a); if(h1==h2)return true; else return false;} bool operator == (char *a,const HugeInt &h1){//重载字符串==巨型整数 HugeInt h2(a); if(h1==h2)return true; else return false;} bool operator == (const HugeInt &h1,long a){//重载巨型整数==长整数 HugeInt h2(a); if(h1==h2)return true; else return false;} bool operator == (long a,const HugeInt &h1){//重载长整数==巨型整数 HugeInt h2(a); if(h1==h2)return true; else return false;} bool operator != (const HugeInt &h1,const HugeInt &h2){//重载巨型整数!=巨型整数 if(h1==h2)return false; return true;} bool operator != (const HugeInt &h1,char *a){ //重载巨型整数!=字符串 HugeInt h2(a); if(h1==h2)return false; else return true;} bool operator != (char *a,const HugeInt &h1){//重载字符串!=巨型整数 HugeInt h2(a); if(h1==h2)return false; else return true;} bool operator != (const HugeInt &h1,long a){//重载巨型整数!=长整数 HugeInt h2(a); if(h1==h2)return false; else return true;} bool operator != (long a,const HugeInt &h1){//重载长整数!=巨型整数 HugeInt h2(a); if(h1==h2)return false; else return true;} bool operator > (const HugeInt &h1,const HugeInt &h2){//重载巨型整数>巨型整数 //如果第一个是正数,第二个是负数,则返回true if(h1.hugeint[0]=='+'&&h2.hugeint[0]=='-')return true; //如果第一个是负数,第二个是正数,则返回false if(h1.hugeint[0]=='-'&&h2.hugeint[0]=='+')return false; //判断同为正号两个数的大小 if(h1.hugeint[0]=='+'&&h2.hugeint[0]=='+') { //如果第一个长度大于第二个长度,则返回true if(h1.hugeint.size()>h2.hugeint.size())return true; //如果第二个长度大于第一个长度,则返回false else if(h1.hugeint.size()<h2.hugeint.size())return false; //处理两种长度一样的情况 else { //从高位依次比较字符大小,如果大则直接返回true for(int i=1;i<h1.hugeint.size();i++) { if(h1.hugeint[i]>h2.hugeint[i]) return true; //如果相等,则跳过继续比较 if(h1.hugeint[i]==h2.hugeint[i])continue; //否则返回false return false; } //全部字符相等则返回false return false; } } //判断同为负号两个数的大小 if(h1.hugeint[0]=='-'&&h2.hugeint[0]=='-') { //如果第一个长度小于第二个长度,则返回true if(h1.hugeint.size()<h2.hugeint.size())return true; //如果第一个长度大于第二个长度,则返回false else if(h1.hugeint.size()>h2.hugeint.size())return false; else { //从高位依次比较字符大小,如果小则直接返回true for(int i=0;i<h1.hugeint.size();i++) if(h1.hugeint[i]<h2.hugeint[i]) return true; //否则返回false return false; } } return true;} bool operator > (const HugeInt &h1,char *a){ //重载巨型整数>字符串 HugeInt h2(a); if(h1>h2)return true; else return false;} bool operator > (char *a,const HugeInt &h1){//重载字符串>巨型整数 HugeInt h2(a); if(h2>h1)return true; else return false;} bool operator > (const HugeInt &h1,long a){//重载巨型整数>长整数 HugeInt h2(a); if(h1>h2)return true; else return false;} bool operator > (long a,const HugeInt &h1){//重载长整数>巨型整数 HugeInt h2(a); if(h2>h1)return true; else return false;} bool operator >= (const HugeInt &h1,const HugeInt &h2){//重载巨型整数>=巨型整数 if(h1>h2||h1==h2)return true; return false;} bool operator >= (const HugeInt &h1,char *a){ //重载巨型整数>=字符串 HugeInt h2(a); if(h1>=h2)return true; else return false;} bool operator >= (char *a,const HugeInt &h1){//重载字符串>=巨型整数 HugeInt h2(a); if(h2>=h1)return true; else return false;} bool operator >= (const HugeInt &h1,long a){//重载巨型整数>=长整数 HugeInt h2(a); if(h1>=h2)return true; else return false;} bool operator >= (long a,const HugeInt &h1){//重载长整数>=巨型整数 HugeInt h2(a); if(h2>=h1)return true; else return false;} bool operator < (const HugeInt &h1,const HugeInt &h2){//重载巨型整数<巨型整数 if(h1>=h2)return false; return true;} bool operator < (const HugeInt &h1,char *a){ //重载巨型整数<字符串 HugeInt h2(a); if(h1>=h2)return false; return true;} bool operator < (char *a,const HugeInt &h1){//重载字符串<巨型整数 HugeInt h2(a); if(h2>=h1)return false; return true;} bool operator < (const HugeInt &h1,long a){//重载巨型整数<长整数 HugeInt h2(a); if(h1>=h2)return false; return true;} bool operator < (long a,const HugeInt &h1){//重载长整数<巨型整数 HugeInt h2(a); if(h2>=h1)return false; return true;} bool operator <= (const HugeInt &h1,const HugeInt &h2){//重载巨型整数<=巨型整数 if(h1<h2||h1==h2)return true; return false;} bool operator <= (const HugeInt &h1,char *a){ //重载巨型整数<=字符串 HugeInt h2(a); if(h1<=h2)return true; else return false;} bool operator <= (char *a,const HugeInt &h1){//重载字符串<=巨型整数 HugeInt h2(a); if(h2<=h1)return true; else return false;} bool operator <= (const HugeInt &h1,long a){//重载巨型整数<=长整数 HugeInt h2(a); if(h1<=h2)return true; else return false;} bool operator <= (long a,const HugeInt &h1){//重载长整数<=巨型整数 HugeInt h2(a); if(h2<=h1)return true; else return false;} HugeInt operator + (HugeInt h1,HugeInt h2){//重载巨型整数+巨型整数 int sign,a; //定义用来标记符号sign和用来存放每一位相加结果的变量a int carry=0;//定义一个变量来存储进位 //定义一个中间变量来存放长度较小的巨型整数 HugeInt t1((h1.hugeint.size()<h2.hugeint.size())?h1:h2); //定义一个中间变量来存放长度较大的巨型整数,并将相加结果存放在t2中 HugeInt t2((h1.hugeint.size()>=h2.hugeint.size())?h1:h2); //处理两个巨型整数同为正或负数情况 if(t1.hugeint[0]==t2.hugeint[0]) { //当同为正号,标记为1,同为负号,标志为0 if(t1.hugeint[0]=='+')sign=1; if(t1.hugeint[0]=='-')sign=0; //将两个数的符号位删除 t1.hugeint.pop_front(); t2.hugeint.pop_front(); for(int i=1;i<=t1.hugeint.size();i++) {//从最后一位开始转化为整形相加并加上进位,直到长度较小的第一位相加结束 a=c_to_i(t1.hugeint[t1.hugeint.size()-i])+c_to_i(t2.hugeint[t2.hugeint.size()-i])+carry; //如果没有进位则进位为0 if(a<=9)carry=0; //如果有进位,则进位为1,且把相加所得数对10取余得到相应的值 if(a>9) { carry=1; a%=10; } //长度较大的相对应的字符修改为相加后的值 t2.hugeint[t2.hugeint.size()-i]=i_to_c(a); } for(int j=1;carry==1&&j<=t2.hugeint.size()-t1.hugeint.size();j++) {//处理长度较大的数的高位加上长度较小的数的最高位有进位后进位情况 a=c_to_i(t2.hugeint[t2.hugeint.size()-t1.hugeint.size()-j])+carry; //如果没有进位则进位为0 if(a<=9)carry=0; //如果有进位,则进位为1,且把相加所得数对10取余得到相应的值 if(a>9) { carry=1; a%=10; } //把相对应的字符修改为相加后的值 t2.hugeint[t2.hugeint.size()-t1.hugeint.size()-j]=i_to_c(a); } //如果长度较大的最高位有进位则必须增加一位最高位1 (例如999+1=1000) if(carry==1)t2.hugeint.push_front('1'); //根据标记在相加后的数前加上相应的符号 if(sign==1)t2.hugeint.push_front('+'); if(sign==0)t2.hugeint.push_front('-'); //返回相加结果 return t2; } //处理第一个数为正数,第二个数为负数时的情况 if(h1.hugeint[0]=='+'&&h2.hugeint[0]=='-') {//把第二个数改为正数再用减法计算,相当于(h1-(-h2)) HugeInt h3(h1-(-h2)); return h3; } //处理第一个数为负数,第二个数为正数时的情况 if(h1.hugeint[0]=='-'&&h2.hugeint[0]=='+') {//把第一个数改为正数再用减法计算,相当于(h2-(-h1)) HugeInt h3(h2-(-h1)); return h3; } return t1;} HugeInt operator + (HugeInt h1,char *a){//重载巨型整数+字符串 HugeInt h2(a); HugeInt h3=h1+h2; return h3;} HugeInt operator + (char *a,HugeInt h1){//重载字符串+巨型整数 HugeInt h2(a); HugeInt h3=h1+h2; return h3;} HugeInt operator + (HugeInt h1,long a){//重载巨型整数+长整数 HugeInt h2(a); HugeInt h3=h1+h2; return h3;} HugeInt operator + (long a,HugeInt h1){//重载长整数+巨型整数 HugeInt h2(a); HugeInt h3=h1+h2; return h3;} HugeInt operator - (HugeInt h1,HugeInt h2){//重载巨型整数-巨型整数 int sign,a; //定义用来标记符号sign和用来存放每一位相加结果的变量a int recede=0;//定义一个变量来存储退位 //定义一个中间变量来存放绝对值较大的巨型整数 HugeInt t1((h1.abs(h1)>=h2.abs(h2))?h1:h2); //定义一个中间变量来存放绝对值较小的巨型整数 HugeInt t2((h1.abs(h1)<h2.abs(h2))?h1:h2); //删除两个巨型整数的符号便于计算 t1.hugeint.pop_front(); t2.hugeint.pop_front(); //处理两个巨型整数同为正或负数情况 if(h1.hugeint[0]==h2.hugeint[0]) { //如果两个巨型整数相等,直接返回+0 if(h1==h2) { HugeInt h3; return h3; } //如果第一个数大于第二个数,则相减结果为正数 if(h1>h2)sign=1; //否则为负数 else sign=0; for(int i=1;i<=t2.hugeint.size();i++) {//从最后一位开始转化为整形相减并减去退位进位,直到绝对值较小的第一位相减结束 a=c_to_i(t1.hugeint[t1.hugeint.size()-i])-c_to_i(t2.hugeint[t2.hugeint.size()-i])-recede; //如果有退位,则把相减所得数对加上10得到相应的值,且退位为1 if(a<0) { a+=10; recede=1; } //否则退位为0 else recede=0; //把相对应的字符修改为相减后的值 t1.hugeint[t1.hugeint.size()-i]=i_to_c(a); } for(int j=t1.hugeint.size()-t2.hugeint.size()-1;j>=0&&recede==1;j--) {//处理绝对值较大的数的高位减去绝对值较小的数的最高位有退位后的退位情况 a=c_to_i(t1.hugeint[j])-recede; //如果有退位,则把相减所得数对加上10得到相应的值,且退位为1 if(a<0) { a+=10; recede=1; } //否则退位为0 else recede=0; //把相对应的字符修改为相减后的值 t1.hugeint[j]=i_to_c(a); } //处理相减完高位上存在的累赘0 (如+00001,结果必须是+1) for(int k=0;t1.hugeint[k]=='0';) t1.hugeint.pop_front(); //根据标记在相减后的数前加上相应的符号 if(sign==1)t1.hugeint.push_front('+'); else t1.hugeint.push_front('-'); //返回相加结果 return t1; } //处理第一个数为正数,第二个数为负数时的情况 if(h1.hugeint[0]=='+'&&h2.hugeint[0]=='-') {//把第二个数改为正数再用加法计算,相当于(h1+(-h2)) HugeInt h3(h1+(-h2)); return h3; } //处理第一个数为负数,第二个数为正数时的情况 if(h1.hugeint[0]=='-'&&h2.hugeint[0]=='+') {//把第一个数改为正数再用加法计算而后再取负,相当于(-(-h1+h2)) HugeInt h3(-(-h1+h2)); return h3; } return h1;} HugeInt operator - (HugeInt h1,char *a){//重载巨型整数-字符串 HugeInt h2(a); HugeInt h3=h1-h2; return h3;} HugeInt operator - (char *a,HugeInt h1){//重载字符串-巨型整数 HugeInt h2(a); HugeInt h3=h2-h1; return h3;} HugeInt operator - (HugeInt h1,long a){//重载巨型整数-长整数 HugeInt h2(a); HugeInt h3=h1-h2; return h3;} HugeInt operator - (long a,HugeInt h1){//重载长整数-巨型整数 HugeInt h2(a); HugeInt h3=h2-h1; return h3;} HugeInt operator * (HugeInt h1,HugeInt h2){//重载巨型整数*巨型整数 int sign; //定义用来标记符号sign HugeInt b; //定义一个数为+0,用来比较 //如果其中有一个数为+0,直接返回+0 if(h1==b||h2==b)return b; //如果两个数的符号相同,则最后结果为正数 if(h1.hugeint[0]==h2.hugeint[0])sign=1; //如果符号不同,则最后结果为负数 else sign=0; //删除两个数的符号 h1.hugeint.pop_front(); h2.hugeint.pop_front(); //定义一个中间变量来存放长度较大的巨型整数 HugeInt t1((h1.hugeint.size()>=h2.hugeint.size())?h1:h2); //定义一个中间变量来存放长度较小的巨型整数 HugeInt t2((h1.hugeint.size()<h2.hugeint.size())?h1:h2); //为被加数加上符号便于计算 t1.hugeint.push_front('+'); //申请巨型整数空间来存放每一次迭加后的值 HugeInt *p=new HugeInt[t2.hugeint.size()]; for(int i=t2.hugeint.size()-1;i>=0;i--) {/*从长度较小的最后一位开始迭加,迭加次数为其转化为整型后的值. (例如123*24,第一次把123迭加4次存放到相应空间中如(p[0]中),再把123迭加2次后放入另一空间中如(p[1])中)*/ HugeInt a;//定义一个中间变量来进行迭加 for(int j=0;j<c_to_i(t2.hugeint[i]);j++) { a=a+t1; } //把迭加后的数存放到相应的巨型整数后再处理 p[t2.hugeint.size()-1-i]=a; } HugeInt sum;//用来存放最终结果 //将每一次的结果相加得到最终结果 for (int k=0;k<t2.hugeint.size();k++) { /*为每个迭加后的数(不包括+0)乘上相应的10^m(10的m次方). (例如上面的123*24,迭加完以后,p[0]中的值要乘以10的0次方, p[1]中的值要乘以10的1次方)*/ for (int m=0;m<k&&p[k]!=b;m++) { p[k].hugeint.push_back('0'); } //最后把每个值相加得到最终结果 sum=sum+p[k]; } //根据标志为计算结果加上相应的符号 if(sign==1)sum.hugeint[0]='+'; else sum.hugeint[0]='-'; //返回最终计算结果 return sum;} HugeInt operator * (HugeInt h1,char *a){//重载巨型整数*字符串 HugeInt h2(a); HugeInt h3=h1*h2; return h3;} HugeInt operator * (char *a,HugeInt h1){//重载字符串*巨型整数 HugeInt h2(a); HugeInt h3=h2*h1; return h3;} HugeInt operator * (HugeInt h1,long a){//重载巨型整数*长整数 HugeInt h2(a); HugeInt h3=h1*h2; return h3;} HugeInt operator * (long a,HugeInt h1){//重载长整数*巨型整数 HugeInt h2(a); HugeInt h3=h2*h1; return h3;} HugeInt quotient (HugeInt h1,HugeInt h2){//用于除法中的商值函数 HugeInt h3=h2; h3.hugeint.push_front('+'); for(int i=0;(h3*i)<=h1;i++); return (i-1);} HugeInt diff (HugeInt h1,HugeInt h2){//用于除法中的差值函数 HugeInt h3=h2; h3.hugeint.push_front('+'); HugeInt temp=h1-h3*quotient(h1,h2); return temp;} HugeInt operator / (HugeInt h1,HugeInt h2){//重载巨型整数/巨型整数 int sign; //定义用来标记符号sign HugeInt a; //定义一个数为+0,用来比较 if(h2==a)throw wrong_deno();//如果分母为+0抛出异常 //存放两个数的绝对值,用来比较大小 HugeInt t1=h1.abs(h1),t2=h2.abs(h2); if(t1<t2)return a;//如果被除数小于除数,直接返回+0 //如果两个数的符号相同,则最后结果为正数 if(h1.hugeint[0]==h2.hugeint[0])sign=1; //如果符号不同,则最后结果为负数 else sign=0; //定义一个巨型整数数组来存放每次相除后的商 HugeInt *p=new HugeInt[h1.hugeint.size()-h2.hugeint.size()+1]; //定义一个巨型整数数组来存放每次相除并相减后的差 HugeInt *q=new HugeInt[h1.hugeint.size()-h2.hugeint.size()+1]; //删除两个数的符号 h1.hugeint.pop_front(); h2.hugeint.pop_front(); //定义用来存放每一次除法中的被除数 HugeInt dividend; //清除其中原有0,使其只存在一个+号 dividend.hugeint.pop_back(); //往被除数中存入初始的被除数 for(int i=0;i<h2.hugeint.size();i++) dividend.hugeint.push_back(h1.hugeint[i]); HugeInt sum;//用来存放最终结果 for(int j=0;j<h1.hugeint.size()-h2.hugeint.size()+1;j++) { if(j>=1) { //将前一次得到的差值存放到被除数中 dividend=q[j-1]; //遇到差值为+0时,把0删掉,剩下一个+号 if(dividend==a)dividend.hugeint.pop_back(); //把下一位存放到被除数的后面,形成新的被除数 dividend.hugeint.push_back(h1.hugeint[h2.hugeint.size()-1+j]); } p[j]=quotient(dividend,h2); //相除后的商值 q[j]=diff(dividend,h2); //相除并相减的差值 for(int k=h1.hugeint.size()-h2.hugeint.size();k>j&&p[j]!=a;k--) {//为每个商值(不包括+0)乘上相应的10^(k-j)(10的(k-j)次方). p[j].hugeint.push_back('0'); } //将得到的所有值相加得到最终结果 sum=sum+p[j]; } //根据标志为计算结果加上相应的符号 if(sign==1)sum.hugeint[0]='+'; else sum.hugeint[0]='-'; //返回最终计算结果 return sum;} HugeInt operator / (HugeInt h1,char *a){//重载巨型整数/字符串 HugeInt h2(a); HugeInt h3=h1/h2; return h3;} HugeInt operator / (char *a,HugeInt h1){//重载字符串/巨型整数 HugeInt h2(a); HugeInt h3=h2/h1; return h3;} HugeInt operator / (HugeInt h1,long a){//重载巨型整数/长整数 HugeInt h2(a); HugeInt h3=h1/h2; return h3;} HugeInt operator / (long a,HugeInt h1){//重载长整数/巨型整数 HugeInt h2(a); HugeInt h3=h2/h1; return h3;} HugeInt operator % (HugeInt h1,HugeInt h2){//重载巨型整数%巨型整数 return h1-h1/h2*h2;} HugeInt operator % (HugeInt h1,char *a){//重载巨型整数%字符串 HugeInt h2(a); HugeInt h3=h1%h2; return h3;} HugeInt operator % (char *a,HugeInt h1){//重载字符串%巨型整数 HugeInt h2(a); HugeInt h3=h2%h1; return h3;} HugeInt operator % (HugeInt h1,long a){//重载巨型整数%长整数 HugeInt h2(a); HugeInt h3=h1%h2; return h3;} HugeInt operator % (long a,HugeInt h1){//重载长整数%巨型整数 HugeInt h2(a); HugeInt h3=h2%h1; return h3;} HugeInt quot (HugeInt h){//开平方运算中求出初始试商 for(int i=0;i*i<=h;i++); return i-1;} HugeInt sqrt_quot (HugeInt h1,HugeInt h2){//开平方运算中求商值函数 for(int i=0;(20*h1+i)*i<=h2;i++); if(h2<20*h1)return 0l; return i-1;} HugeInt sqrt_diff (HugeInt h1,HugeInt h2){//开平方运算中求差值函数 HugeInt temp=h2-(20*h1+sqrt_quot(h1,h2))*sqrt_quot(h1,h2); return temp;} HugeInt sqrt(HugeInt h){//对巨型整数进行开平方 HugeInt a; //定义一个数为+0,用来比较 //如果巨型整数小于0则抛出异常 if(h<a)throw Illegal(); //定义用来存放每一次除法中的被除数 HugeInt dividend; //清除其中原有0,使其只存在一个+号 dividend.hugeint.pop_back(); HugeInt sum;//用来存放最终结果 //定义一个巨型整数数组来存放每次相除后的商 HugeInt *p=new HugeInt[h.hugeint.size()/2+100]; //定义一个巨型整数数组来存放每次相除并相减后的差 HugeInt *q=new HugeInt[h.hugeint.size()/2+100]; HugeInt h0;//定义一个中间变量来存储一串商值 h0.hugeint.clear();//清除原有的值，以免影响结果 //将原值赋给另一个变量并清除其符号 HugeInt h1=h; h1.hugeint.pop_front(); //处理整数位数为奇数的情况 if(h1.hugeint.size()%2!=0) { //求出初始被除数 dividend.hugeint.push_back(h1.hugeint[0]); //求出初始试商 p[0]=quot(dividend); //存放初始商值 h0=quot(dividend); //存放初始商值 q[0]=dividend-p[0]*p[0]; //存放第一次相减后的差值 for(int i=0;i<(h1.hugeint.size()/2+1);i++) { if(i>=1) { //将前一次得到的差值存放到被除数中 dividend=q[i-1]; //遇到差值为+0时,把0删掉,剩下一个+号 if(dividend==a)dividend.hugeint.pop_back(); //把后面两位存放到被除数的后面,形成新的被除数 dividend.hugeint.push_back(h1.hugeint[i*2-1]); dividend.hugeint.push_back(h1.hugeint[i*2]); //如果压入前就只剩一个加号,且后面压入的第一个为0,则把第一个0删去 if(dividend.hugeint[1]=='0') { char n=dividend.hugeint[2]; dividend.hugeint.pop_back(); dividend.hugeint.pop_back(); dividend.hugeint.push_back(n); } p[i]=sqrt_quot(h0,dividend); //存放每一位商值 q[i]=sqrt_diff(h0,dividend);//存放每一个差值 h0.hugeint.push_back(p[i].hugeint[1]);//把其他各位上的数加到商中 } //为每个商值(不包括+0)乘上相应的10^(j-i)(10的(j-i)次方). for(int j=i;j<h1.hugeint.size()/2&&p[i]!=a;j++) p[i].hugeint.push_back('0'); //将得到的所有值相加得到最终结果 sum=sum+p[i]; } //返回最终计算结果 return sum; } //处理整数位数为偶数的情况 else { //求出初始被除数 dividend.hugeint.push_back(h1.hugeint[0]); dividend.hugeint.push_back(h1.hugeint[1]); //求出初始试商 p[0]=quot(dividend); //存放初始商值 h0=quot(dividend); //存放初始商值 q[0]=dividend-p[0]*p[0]; //存放第一次相减后的差值 for(int i=0;i<(h1.hugeint.size()/2);i++) { if(i>=1) { //将前一次得到的差值存放到被除数中 dividend=q[i-1]; //遇到差值为+0时,把0删掉,剩下一个+号 if(dividend==a)dividend.hugeint.pop_back(); //把后面两位存放到被除数的后面,形成新的被除数 dividend.hugeint.push_back(h1.hugeint[i*2]); dividend.hugeint.push_back(h1.hugeint[i*2+1]); //如果压入前就只剩一个加号,且后面压入的两个都是0,则删除一个0 if(dividend.hugeint[1]=='0') { char n=dividend.hugeint[2]; dividend.hugeint.pop_back(); dividend.hugeint.pop_back(); dividend.hugeint.push_back(n); } p[i]=sqrt_quot(h0,dividend); //存放每一位商值 q[i]=sqrt_diff(h0,dividend);//存放每一个差值 h0.hugeint.push_back(p[i].hugeint[1]); } //为每个商值(不包括+0)乘上相应的10^(j-i)(10的(j-i)次方). for(int j=i;j<h1.hugeint.size()/2-1&&p[i]!=a;j++) p[i].hugeint.push_back('0'); //将得到的所有值相加得到最终结果 sum=sum+p[i]; } //返回最终计算结果 return sum; }} //-------------------------------------类友元函数实现结束---------------------------------------// //-------------------------------------普通函数实现开始-----------------------------------------// int c_to_i(char c){//将字符型转化为整型 return(c-'0');} char i_to_c(int a){//将整型转化为字符型 return(a+'0');} //-------------------------------------普通函数实现结束-----------------------------------------// /******************************** 主函数开始 ***********************************//************************************ **************************************/int main(){ HugeInt h1; //使用缺省值构造函数定义对象 cout<<"第1个巨型整数(缺省值)为:"<<h1; HugeInt h2(-123456789); //使用长整数构造函数定义对象 cout<<"第2个巨型整数(用长整数初始化)为:"<<h2; HugeInt h3("12345678901234567890");//使用字符串构造函数定义对象 cout<<"第3个巨型整数(用字符串初始化,无符号自动加上正号)为:"<<h3; /*以下几句只本程序适用! HugeInt h4("-");//使用一个负号进行构造,自动处理为+0 cout<<"第4个巨型整数(使用一个负号进行构造)为:"<<h4; HugeInt h5("+");//使用一个正号进行构造,自动处理为+0 cout<<"第5个巨型整数(使用一个正号进行构造)为:"<<h5; HugeInt h6("-0");//使用-0进行构造,自动处理为+0 cout<<"第6个巨型整数(使用-0进行构造)为:"<<h6; HugeInt h7("0");//使用0进行构造,自动处理为+0 cout<<"第7个巨型整数(使用0进行构造)为:"<<h7; */ try { HugeInt t1("0123");//使用非法字符串定义对象 } catch(...) { cout<<"使用HugeInt t1(\"0123\")定义对象后抛出非法巨型整数异常!"<<endl; } try { HugeInt t2("123radfg598feg");//使用非法字符串定义对象 } catch(...) { cout<<"使用HugeInt t2(\"123radfg598feg\")定义对象后抛出非法巨型整数异常!"<<endl; } cout<<endl<<"下面将对巨型整数的输入和输出进行测试,按任意键继续......\n"; getch(); cout<<endl; HugeInt t3; cout<<"通过HugeInt t3;构造一个对象,其默认值为:"<<t3<<"下面通过重新输入,并进行输入的合法性进行测试,为t3重新定义值!"; try { cout<<endl<<"请输入一个巨型整数:"; cin>>t3; //通过重新输入,为t3重新定义值! cout<<"输入合法,您已经成功为t3重新定义了值,t3为:"<<t3; } catch(...) { cout<<"您输入的巨型整数不合法!无法为t3重新定义值,t3的值为:"<<t3; } cout<<endl<<"下面将对巨型整数的拷贝构造,赋值,修改函数进行测试,按任意键继续......\n"; getch(); cout<<endl; HugeInt t4("-12345678901234567890123456789"); cout<<"通过字符串构造一个巨型整数t4,其值为:"<<t4; HugeInt t5(t4); cout<<"执行HugeInt t5(t4)后,输出t5的值为:"<<t5; HugeInt t6; cout<<"通过缺省参数构造一个巨型整数t6,其值为:"<<t6; t6=t5; cout<<"执行t6=t5后,输出t6的值为:"<<t6; /*以下四句只适用于修改函数名为set_hugeint的程序 t6.set_hugeint(12345); cout<<"使用修改函数(长整型),执行t6.set_hugeint(12345);后t6="<<t6; t6.set_hugeint("-987654321"); cout<<"使用修改函数(字符串),执行t6.set_hugeint(\"-987654321\");后t6="<<t6; */ //--------------------------------测试关系运算符------------------------------------------// cout<<endl<<"下面将对巨型整数的关系运算符重载(==和!=)进行测试,按任意键继续......\n"; getch(); cout<<endl; cout<<"现在测试重载的==号!"<<endl; HugeInt n1(123456),n2("+123456"); cout<<"分别使用长整数和字符串构造巨型整数n1和n2,HugeInt n1(123456),n2(\"+123456\");"<<endl; if(n1==n2)cout<<"n1=n2"<<endl; long a=123456; char *b="123456"; cout<<"定义一个长整数a="<<a<<",一个字符串b="<<b<<endl; if(n1==a)cout<<"n1=a"<<endl; if(n1==b)cout<<"n1=b"<<endl; if(a==n1)cout<<"a=n1"<<endl; if(b==n1)cout<<"b=n1"<<endl; cout<<"现在测试重载的!=号!"<<endl; HugeInt n3(-123),n4("12345678"); long c=-123456; char *d="-12312312312313231311313"; cout<<"分别使用长整数和字符串构造巨型整数n3和n4,HugeInt n3(-123),n4(\"12345678\");"<<endl; cout<<"定义一个长整数c="<<c<<",一个字符串d="<<d<<endl; if(n1!=n3)cout<<"n1!=n3"<<endl; if(n1!=c)cout<<"n1!=c"<<endl; if(n1!=d)cout<<"n1!=d"<<endl; if(c!=n1)cout<<"c!=n1"<<endl; if(d!=n1)cout<<"d!=n1"<<endl; cout<<endl<<"下面将对巨型整数的关系运算符重载(>和>=)进行测试,按任意键继续......\n"; getch(); cout<<endl; cout<<"现在测试重载的>号!"<<endl; long e=456123; char *f="789652"; cout<<"定义一个长整数e="<<e<<",一个字符串f="<<f<<endl; cout<<"n1="<<n1<<"n4="<<n4<<"c="<<c<<",d="<<d<<endl; if(n4>n1)cout<<"n4>n1"<<endl; if(n1>c)cout<<"n1>c"<<endl; if(n1>d)cout<<"n1>d"<<endl; if(e>n1)cout<<"e>n1"<<endl; if(f>n1)cout<<"f>n1"<<endl; cout<<"现在测试重载的>=号!"<<endl; cout<<"n1="<<n1<<"n2="<<n2<<"n4="<<n4<<"a="<<a<<",b="<<b<<endl; cout<<"c="<<c<<",d="<<d<<endl<<"e="<<e<<",f="<<f<<endl; if(n1>=n2)cout<<"n1>=n2"<<endl; if(n4>=n1)cout<<"n4>=n1"<<endl; if(n1>=a)cout<<"n1>=a"<<endl; if(n1>=b)cout<<"n1>=b"<<endl; if(a>=n1)cout<<"a>=n1"<<endl; if(b>=n1)cout<<"b>=n1"<<endl; if(n1>=c)cout<<"n1>=c"<<endl; if(n1>=d)cout<<"n1>=d"<<endl; if(e>=n1)cout<<"e>=n1"<<endl; if(f>=n1)cout<<"f>=n1"<<endl; cout<<endl<<"下面将对巨型整数的关系运算符重载(<和<=)进行测试,按任意键继续......\n"; getch(); cout<<endl; cout<<"现在测试重载的<号!"<<endl; cout<<"n1="<<n1<<"n3="<<n3; cout<<"c="<<c<<",d="<<d<<endl<<"e="<<e<<",f="<<f<<endl; if(n3<n1)cout<<"n3<n1"<<endl; if(c<n1)cout<<"c<n1"<<endl; if(d<n1)cout<<"d<n1"<<endl; if(n1<e)cout<<"n1<e"<<endl; if(n1<f)cout<<"n1<f"<<endl; cout<<"现在测试重载的<=号!"<<endl; cout<<"n1="<<n1<<"n2="<<n2<<"n3="<<n3<<"a="<<a<<",b="<<b<<endl; cout<<"c="<<c<<",d="<<d<<endl<<"e="<<e<<",f="<<f<<endl; if(n1<=n2)cout<<"n1<=n2"<<endl; if(n3<=n1)cout<<"n3<=n1"<<endl; if(n1<=a)cout<<"n1<=a"<<endl; if(n1<=b)cout<<"n1<=b"<<endl; if(a<=n1)cout<<"a<=n1"<<endl; if(b<=n1)cout<<"b<=n1"<<endl; if(c<=n1)cout<<"c<=n1"<<endl; if(d<=n1)cout<<"d<=n1"<<endl; if(n1<=e)cout<<"n1<=e"<<endl; if(n1<=f)cout<<"n1<=f"<<endl; //--------------------------------测试关系运算符------------------------------------------// //------------------------测试加、减、乘、除、取余、开平方--------------------------------// cout<<endl<<"下面将对巨型整数的加法进行测试,按任意键继续......\n"; getch(); cout<<endl; //负数+正数 HugeInt m1("-12345678901234567890"),m2("12345678901234567890"); cout<<"通过字符串构造巨型整数m1和m2,其值分别为:"<<endl<<"m1="<<m1<<"m2="<<m2; HugeInt m3=m1+m2; cout<<"执行m3=m1+m2后,m3的值为m3="<<m3; //正数+正数 HugeInt m4("99999999999999999999999999999999999999999999999"),m5("8888888888888888888888888888888888888888"); cout<<"通过字符串构造巨型整数m4和m5,其值分别为:"<<endl<<"m4="<<m4<<"m5="<<m5; m3=m4+m5; cout<<"执行m3=m4+m5后,m3的值为m3="<<m3; //正数+负数 HugeInt m6("8888888888888"),m7("-1234597800000"); cout<<"通过字符串构造巨型整数m6和m7,其值分别为:"<<endl<<"m6="<<m6<<"m7="<<m7; m3=m6+m7; cout<<"执行m3=m6+m7后,m3的值为m3="<<m3; //负数+负数(巨型整数与长整数和字符串之间的加法) long g=-9999999; char *h="-8888888888889"; HugeInt m8(-1); cout<<"通过长整数构造巨型整数m8,其值为:"<<endl<<"m8="<<m8; cout<<"定义一个长整数g="<<g<<",一个字符串h="<<h<<endl; m3=m8+g; cout<<"执行m3=m8+g后,m3的值为m3="<<m3; m3=g+m8; cout<<"执行m3=g+m8后,m3的值为m3="<<m3; m3=m8+h; cout<<"执行m3=m8+h后,m3的值为m3="<<m3; m3=h+m8; cout<<"执行m3=h+m8后,m3的值为m3="<<m3; //巨型整数+=巨型整数 cout<<"下面测试运算符+="<<endl; cout<<"m1="<<m1<<"m2="<<m2; m1+=m2; cout<<"执行m1+=m2后,m1="<<m1; //巨型整数+=长整数 cout<<"m3="<<m3<<"g="<<g<<endl; m3+=g; cout<<"执行m3+=g后,m3="<<m3; //巨型整数+=字符串 cout<<"m6="<<m6<<"h="<<h<<endl; m6+=h; cout<<"执行m6+=h后,m6="<<m6; cout<<endl<<"下面将对巨型整数的减法进行测试,按任意键继续......\n"; getch(); cout<<endl; //正数-正数 HugeInt i1("1000000000000"),i2("1"); cout<<"通过字符串构造巨型整数i1和i2,其值分别为:"<<endl<<"i1="<<i1<<"i2="<<i2; HugeInt i3=i1-i2; cout<<"执行i3=i1-i2后,n3的值为i3="<<i3; //正数-负数 HugeInt i4("9999999999999999999999999"),i5("-1"); cout<<"通过字符串构造巨型整数i4和i5,其值分别为:"<<endl<<"i4="<<i4<<"i5="<<i5; i3=i4-i5; cout<<"执行i3=i4-i5后,n3的值为i3="<<i3; //负数-负数 HugeInt i6("-1234567890123"),i7("-1111111111111"); cout<<"通过字符串构造巨型整数i6和i7,其值分别为:"<<endl<<"i6="<<i6<<"i7="<<i7; i3=i6-i7; cout<<"执行i3=i6-i7后,n3的值为i3="<<i3; //负数-正数(巨型整数与长整数和字符串之间的减法) long i=9999999; char *j="8888888888889"; HugeInt i8(-1); cout<<"通过长整数构造巨型整数i8,其值为:"<<endl<<"i8="<<i8; cout<<"定义一个长整数i="<<i<<",一个字符串j="<<j<<endl; i3=i8-i; cout<<"执行i3=i8-i后,i3的值为i3="<<i3; i3=i-i8; cout<<"执行i3=i-i8后,i3的值为i3="<<i3; i3=i8-j; cout<<"执行i3=i8-j后,i3的值为i3="<<i3; i3=j-i8; cout<<"执行i3=j-i8后,i3的值为i3="<<i3; //巨型整数-=巨型整数 cout<<"下面测试运算符-="<<endl; cout<<"i1="<<i1<<"i2="<<i2; i1-=i2; cout<<"执行i1-=i2后,i1="<<i1; //巨型整数-=长整数 cout<<"i3="<<i3<<"i="<<i<<endl; i3-=i; cout<<"执行i3-=i后,i3="<<i3; //巨型整数-=字符串 cout<<"i6="<<i6<<"j="<<j<<endl; i6-=j; cout<<"执行i6-=j后,i6="<<i6; cout<<endl<<"下面将对巨型整数的乘法进行测试,按任意键继续......\n"; getch(); cout<<endl; //正数*正数(100位*100位) HugeInt k1("1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111"); HugeInt k2("9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999"); cout<<"通过字符串构造巨型整数k1和k2,其值分别为:"<<endl<<"k1="<<k1<<"k2="<<k2; HugeInt k3=k1*k2; cout<<"执行k3=k1*k2后,k3的值为k3="<<k3; //正数*负数 HugeInt k4("11111111111"),k5("-1234567890"); cout<<"通过字符串构造巨型整数k4和k5,其值分别为:"<<endl<<"k4="<<k4<<"k5="<<k5; k3=k4*k5; cout<<"执行k3=k4*k5后,k3的值为k3="<<k3; //负数*负数 HugeInt k6("-11111111111"),k7("-1234567890"); cout<<"通过字符串构造巨型整数k6和k7,其值分别为:"<<endl<<"k6="<<k6<<"k7="<<k7; k3=k6*k7; cout<<"执行k3=k6*k7后,k3的值为k3="<<k3; //负数*正数(巨型整数与长整数和字符串之间的乘法) long k=9999999; char *l="8888888888889"; HugeInt k8("-111111111111111111"); cout<<"通过字符串构造巨型整数k8,其值为:"<<endl<<"k8="<<k8; cout<<"定义一个长整数k="<<k<<",一个字符串l="<<l<<endl; k3=k8*k; cout<<"执行k3=k8*k后,k3的值为k3="<<k3; k3=k*k8; cout<<"执行k3=k*k8后,k3的值为k3="<<k3; k3=k8*l; cout<<"执行k3=k8*l后,k3的值为k3="<<k3; k3=l*k8; cout<<"执行k3=l*k8后,k3的值为k3="<<k3; //巨型整数*=巨型整数 cout<<"下面测试运算符*="<<endl; cout<<"k4="<<k4<<"k5="<<k5; k4*=k5; cout<<"执行k4*=k5后,k4="<<k4; //巨型整数*=长整数 cout<<"k3="<<k3<<"k="<<k<<endl; k3*=k; cout<<"执行k3*=k后,k3="<<k3; //巨型整数*=字符串 cout<<"k6="<<k6<<"l="<<l<<endl; k6*=l; cout<<"执行k6*=l后,k6="<<k6; cout<<endl<<"下面将对巨型整数的除法进行测试,按任意键继续......\n"; getch(); cout<<endl; //正数/正数 HugeInt p1("99999"); HugeInt p2("1000"); cout<<"通过字符串构造巨型整数p1和p2,其值分别为:"<<endl<<"p1="<<p1<<"p2="<<p2; HugeInt p3=p1/p2; cout<<"执行p3=p1/p2后,p3的值为p3="<<p3; //正数/负数 HugeInt p4("999999999999999999999999999999999999999999999999999999999999999999"); HugeInt p5("111111111111111111111111111111111111111111111111111111111111112"); cout<<"通过字符串构造巨型整数p4和p5,其值分别为:"<<endl<<"p4="<<p4<<"p5="<<p5; p3=p4/p5; cout<<"执行p3=p4/p5后,p3的值为p3="<<p3; //负数/正数 HugeInt p6(-999999),p7(123456); cout<<"通过长整数构造巨型整数p6和p7,其值分别为:"<<endl<<"p6="<<p6<<"p7="<<p7; p3=p6/p7; cout<<"执行p3=p6/p7后,p3的值为p3="<<p3; //负数/负数(巨型整数与长整数和字符串之间的除法) long p=-9999999; char *q="-8888888888888"; HugeInt p8("-1111"); cout<<"通过字符串构造巨型整数p8,其值为:"<<endl<<"p8="<<p8; cout<<"定义一个长整数p="<<p<<",一个字符串q="<<q<<endl; p3=p8/p; cout<<"执行p3=p8/p后,p3的值为p3="<<p3; p3=p/p8; cout<<"执行p3=p/p8后,p3的值为p3="<<p3; p3=p8/q; cout<<"执行p3=k8/q后,p3的值为p3="<<p3; p3=q/p8; cout<<"执行p3=q/p8后,p3的值为p3="<<p3; //除0异常 cout<<"下面检测是否为除数除0异常!"<<endl; cout<<"p8="<<p8<<"h1"<<h1; try { p3=p8/h1; } catch(...) { cout<<"执行p3=p8/h1;分母检测中..."<<endl; cout<<"发现分母为0异常!!!!"<<endl; } try { p3=p8/0l; } catch(...) { cout<<"执行p3=p8/0l;分母检测中..."<<endl; cout<<"发现分母为0异常!!!!"<<endl; } char *ch="0"; cout<<"定义一个字符串ch,存放0,ch="<<ch<<endl; try { p3=p8/ch; } catch(...) { cout<<"执行p3=p8/ch;分母检测中..."<<endl; cout<<"发现分母为0异常!!!!"<<endl; } //巨型整数/=巨型整数 cout<<"下面测试运算符/="<<endl; cout<<"p1="<<p1<<"p2="<<p2; p1/=p2; cout<<"执行p1/=p2后,p1="<<p1; //巨型整数/=长整数 cout<<"p7="<<p7<<"p="<<p<<endl; p7/=p; cout<<"执行p7/=p后,p7="<<p7; //巨型整数/=字符串 cout<<"p6="<<p6<<"q="<<l<<endl; p6/=q; cout<<"执行p6/=q后,p6="<<p6; cout<<endl<<"下面将对巨型整数的取余进行测试,按任意键继续......\n"; getch(); cout<<endl; //正数%正数 HugeInt r1("11111111111"),r2("22222222"); cout<<"通过字符串构造巨型整数r1和r2,其值分别为:"<<endl<<"r1="<<r1<<"r2="<<r2; HugeInt r3=r1%r2; cout<<"执行r3=r1%r2后,r3="<<r3; //正数%负数 HugeInt r4("100"),r5(-7); cout<<"通过字符串和长整数构造巨型整数r4和r5,其值分别为:"<<endl<<"r4="<<r4<<"r5="<<r5; r3=r4%r5; cout<<"执行r3=r4%r5后,r3="<<r3; //负数%正数 HugeInt r6(-100),r7(7); cout<<"通过字符串和长整数构造巨型整数r6和r7,其值分别为:"<<endl<<"r6="<<r6<<"r7="<<r7; r3=r6%r7; cout<<"执行r3=r6%r7后,r3="<<r3; //负数%负数 long r=-3; char *s="-8"; HugeInt r8("-100"); cout<<"通过字符串构造巨型整数r8,其值为:"<<endl<<"r8="<<r8; cout<<"定义一个长整数r="<<r<<",一个字符串s="<<s<<endl; r3=r8%r; cout<<"执行r3=r8%r后,r3的值为r3="<<r3; r3=r%r8; cout<<"执行r3=r%r8后,r3的值为r3="<<r3; r3=r8%s; cout<<"执行r3=r8%s后,r3的值为r3="<<r3; r3=s%r8; cout<<"执行r3=s%r8后,r3的值为r3="<<r3; //巨型整数%=巨型整数 cout<<"下面测试运算符%="<<endl; cout<<"r1="<<r1<<"r2="<<r2; r1%=r2; cout<<"执行r1%=r2后,r1="<<r1; //巨型整数%=长整数 cout<<"r7="<<r7<<"r="<<r<<endl; r7%=r; cout<<"执行r7%=r后,r7="<<r7; //巨型整数%=字符串 cout<<"r6="<<r6<<"s="<<s<<endl; r6%=s; cout<<"执行r6%=s后,r6="<<r6; /*本段只适用于具有对进行巨型整数开平方运算的程序! cout<<endl<<"下面将对巨型整数的开平方进行测试,按任意键继续......\n"; getch(); cout<<endl; HugeInt u1("12345678987654321"); cout<<"通过字符串构造一个巨型整数u1="<<u1; HugeInt u2=sqrt(u1); cout<<"执行u2=sqrt(u1)后,u2="<<u2; //除负异常 HugeInt u3("-12345678987654321"); cout<<"通过字符串构造一个巨型整数u3="<<u3; try { u2=sqrt(u3); } catch(...) { cout<<"执行u2=sqrt(u3),检测u3是否为负数..."<<endl; cout<<"发现u3为负异常!"<<endl; } */ //------------------------测试加、减、乘、除、取余、开平方--------------------------------// //************************测试求负、前++、后++、前--、后--********************************// cout<<endl<<"下面将对巨型整数的求负进行测试,按任意键继续......\n"; getch(); cout<<endl; //对正数求负 HugeInt v1("+1111111111111111111111111111111111111111"); cout<<"通过字符串构造一个巨型整数,v1="<<v1; HugeInt v2=-v1; cout<<"执行v2=-v1后,v2="<<v2; //对负数求负 HugeInt v3("-123456789123"); cout<<"通过字符串构造一个巨型整数,v3="<<v3; v2=-v3; cout<<"执行v2=-v3后,v2="<<v2; //对0示负 HugeInt v4; cout<<"通过缺省参数构造构造一个巨型整数,v4="<<v4; v2=-v4; cout<<"执行v2=-v4后,v2="<<v2; cout<<endl<<"下面将对巨型整数的前++、后++、前--、后--进行测试,按任意键继续......\n"; getch(); cout<<endl; //测试巨型整数前++ HugeInt w1("9999999999999999999999999999999999"); cout<<"通过字符串构造一个巨型整数,w1="<<w1; HugeInt w2=w1++; cout<<"执行w2=w1++后,w2="<<w2<<"w1="<<w1; //测试巨型整数后++ HugeInt x1("-100000000000000"); cout<<"通过字符串构造一个巨型整数,x1="<<x1; HugeInt x2=++x1; cout<<"执行x2=++x1后,x2="<<x2<<"x1="<<x1; //测试巨型整数前-- HugeInt y1("10000000000000000"); cout<<"通过字符串构造一个巨型整数,y1="<<y1; HugeInt y2=y1--; cout<<"执行y2=y1--后,y2="<<y2<<"y1="<<y1; //测试巨型整数后-- HugeInt z1("-99999999999999"); cout<<"通过字符串构造一个巨型整数,z1="<<z1; HugeInt z2=--z1; cout<<"执行z2=--z1后,z2="<<z2<<"z1="<<z1; //************************测试求负、前++、后++、前--、后--********************************// return 0;}/******************************** 主函数结束 ***********************************//************************************ **************************************/ /************************************输出结果**************************************************** 第1个巨型整数(缺省值)为:+0第2个巨型整数(用长整数初始化)为:-123456789第3个巨型整数(用字符串初始化,无符号自动加上正号)为:+12345678901234567890使用HugeInt t1("0123")定义对象后抛出非法巨型整数异常!使用HugeInt t2("123radfg598feg")定义对象后抛出非法巨型整数异常! 下面将对巨型整数的输入和输出进行测试,按任意键继续...... 通过HugeInt t3;构造一个对象,其默认值为:+0下面通过重新输入,并进行输入的合法性进行测试,为t3重新定义值!请输入一个巨型整数:123输入合法,您已经成功为t3重新定义了值,t3为:+123 下面将对巨型整数的拷贝构造,赋值,修改函数进行测试,按任意键继续...... 通过字符串构造一个巨型整数t4,其值为:-12345678901234567890123456789执行HugeInt t5(t4)后,输出t5的值为:-12345678901234567890123456789通过缺省参数构造一个巨型整数t6,其值为:+0执行t6=t5后,输出t6的值为:-12345678901234567890123456789使用修改函数(长整型),执行t6.set_hugeint(12345);后t6=+12345使用修改函数(字符串),执行t6.set_hugeint("-987654321");后t6=-987654321 下面将对巨型整数的关系运算符重载(==和!=)进行测试,按任意键继续...... 现在测试重载的==号!分别使用长整数和字符串构造巨型整数n1和n2,HugeInt n1(123456),n2("+123456");n1=n2定义一个长整数a=123456,一个字符串b=123456n1=an1=ba=n1b=n1现在测试重载的!=号!分别使用长整数和字符串构造巨型整数n3和n4,HugeInt n3(-123),n4("12345678");定义一个长整数c=-123456,一个字符串d=-12312312312313231311313n1!=n3n1!=cn1!=dc!=n1d!=n1 下面将对巨型整数的关系运算符重载(>和>=)进行测试,按任意键继续...... 现在测试重载的>号!定义一个长整数e=456123,一个字符串f=789652n1=+123456n4=+12345678c=-123456,d=-12312312312313231311313n4>n1n1>cn1>de>n1f>n1现在测试重载的>=号!n1=+123456n2=+123456n4=+12345678a=123456,b=123456c=-123456,d=-12312312312313231311313e=456123,f=789652n1>=n2n4>=n1n1>=an1>=ba>=n1b>=n1n1>=cn1>=de>=n1f>=n1 下面将对巨型整数的关系运算符重载(<和<=)进行测试,按任意键继续...... 现在测试重载的<号!n1=+123456n3=-123c=-123456,d=-12312312312313231311313e=456123,f=789652n3<n1c<n1d<n1n1<en1<f现在测试重载的<=号!n1=+123456n2=+123456n3=-123a=123456,b=123456c=-123456,d=-12312312312313231311313e=456123,f=789652n1<=n2n3<=n1n1<=an1<=ba<=n1b<=n1c<=n1d<=n1n1<=en1<=f 下面将对巨型整数的加法进行测试,按任意键继续...... 通过字符串构造巨型整数m1和m2,其值分别为:m1=-12345678901234567890m2=+12345678901234567890执行m3=m1+m2后,m3的值为m3=+0通过字符串构造巨型整数m4和m5,其值分别为:m4=+99999999999999999999999999999999999999999999999m5=+8888888888888888888888888888888888888888执行m3=m4+m5后,m3的值为m3=+100000008888888888888888888888888888888888888887通过字符串构造巨型整数m6和m7,其值分别为:m6=+8888888888888m7=-1234597800000执行m3=m6+m7后,m3的值为m3=+7654291088888通过长整数构造巨型整数m8,其值为:m8=-1定义一个长整数g=-9999999,一个字符串h=-8888888888889执行m3=m8+g后,m3的值为m3=-10000000执行m3=g+m8后,m3的值为m3=-10000000执行m3=m8+h后,m3的值为m3=-8888888888890执行m3=h+m8后,m3的值为m3=-8888888888890下面测试运算符+=m1=-12345678901234567890m2=+12345678901234567890执行m1+=m2后,m1=+0m3=-8888888888890g=-9999999执行m3+=g后,m3=-8888898888889m6=+8888888888888h=-8888888888889执行m6+=h后,m6=-1 下面将对巨型整数的减法进行测试,按任意键继续...... 通过字符串构造巨型整数i1和i2,其值分别为:i1=+1000000000000i2=+1执行i3=i1-i2后,n3的值为i3=+999999999999通过字符串构造巨型整数i4和i5,其值分别为:i4=+9999999999999999999999999i5=-1执行i3=i4-i5后,n3的值为i3=+10000000000000000000000000通过字符串构造巨型整数i6和i7,其值分别为:i6=-1234567890123i7=-1111111111111执行i3=i6-i7后,n3的值为i3=+123456779012通过长整数构造巨型整数i8,其值为:i8=-1定义一个长整数i=9999999,一个字符串j=8888888888889执行i3=i8-i后,i3的值为i3=-10000000执行i3=i-i8后,i3的值为i3=+10000000执行i3=i8-j后,i3的值为i3=-8888888888890执行i3=j-i8后,i3的值为i3=+8888888888890下面测试运算符-=i1=+1000000000000i2=+1执行i1-=i2后,i1=+999999999999i3=+8888888888890i=9999999执行i3-=i后,i3=+8888878888891i6=-1234567890123j=8888888888889执行i6-=j后,i6=-10123456779012 下面将对巨型整数的乘法进行测试,按任意键继续...... 通过字符串构造巨型整数k1和k2,其值分别为:k1=+1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111k2=+9999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999执行k3=k1*k2后,k3的值为k3=+11111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111108888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888889通过字符串构造巨型整数k4和k5,其值分别为:k4=+11111111111k5=-1234567890执行k3=k4*k5后,k3的值为k3=-13717420999862825790通过字符串构造巨型整数k6和k7,其值分别为:k6=-11111111111k7=-1234567890执行k3=k6*k7后,k3的值为k3=+13717420999862825790通过字符串构造巨型整数k8,其值为:k8=-111111111111111111定义一个长整数k=9999999,一个字符串l=8888888888889执行k3=k8*k后,k3的值为k3=-1111110999999999998888889执行k3=k*k8后,k3的值为k3=-1111110999999999998888889执行k3=k8*l后,k3的值为k3=-987654320987666665679012345679执行k3=l*k8后,k3的值为k3=-987654320987666665679012345679下面测试运算符*=k4=+11111111111k5=-1234567890执行k4*=k5后,k4=-13717420999862825790k3=-987654320987666665679012345679k=9999999执行k3*=k后,k3=-9876542222222345669123457777777654321k6=-11111111111l=8888888888889执行k6*=l后,k6=-98765432097779012345679 下面将对巨型整数的除法进行测试,按任意键继续...... 通过字符串构造巨型整数p1和p2,其值分别为:p1=+99999p2=+1000执行p3=p1/p2后,p3的值为p3=+99通过字符串构造巨型整数p4和p5,其值分别为:p4=+999999999999999999999999999999999999999999999999999999999999999999p5=+111111111111111111111111111111111111111111111111111111111111112执行p3=p4/p5后,p3的值为p3=+8999通过长整数构造巨型整数p6和p7,其值分别为:p6=-999999p7=+123456执行p3=p6/p7后,p3的值为p3=-8通过字符串构造巨型整数p8,其值为:p8=-1111定义一个长整数p=-9999999,一个字符串q=-8888888888888执行p3=p8/p后,p3的值为p3=+0执行p3=p/p8后,p3的值为p3=+9000执行p3=k8/q后,p3的值为p3=+0执行p3=q/p8后,p3的值为p3=+8000800080下面检测是否为除数除0异常!p8=-1111h1+0执行p3=p8/h1;分母检测中...发现分母为0异常!!!!执行p3=p8/0l;分母检测中...发现分母为0异常!!!!定义一个字符串ch,存放0,ch=0执行p3=p8/ch;分母检测中...发现分母为0异常!!!!下面测试运算符/=p1=+99999p2=+1000执行p1/=p2后,p1=+99p7=+123456p=-9999999执行p7/=p后,p7=+0p6=-999999q=8888888888889执行p6/=q后,p6=+0 下面将对巨型整数的取余进行测试,按任意键继续...... 通过字符串构造巨型整数r1和r2,其值分别为:r1=+11111111111r2=+22222222执行r3=r1%r2后,r3=+111通过字符串和长整数构造巨型整数r4和r5,其值分别为:r4=+100r5=-7执行r3=r4%r5后,r3=+2通过字符串和长整数构造巨型整数r6和r7,其值分别为:r6=-100r7=+7执行r3=r6%r7后,r3=-2通过字符串构造巨型整数r8,其值为:r8=-100定义一个长整数r=-3,一个字符串s=-8执行r3=r8%r后,r3的值为r3=-1执行r3=r%r8后,r3的值为r3=-3执行r3=r8%s后,r3的值为r3=-4执行r3=s%r8后,r3的值为r3=-8下面测试运算符%=r1=+11111111111r2=+22222222执行r1%=r2后,r1=+111r7=+7r=-3执行r7%=r后,r7=+1r6=-100s=-8执行r6%=s后,r6=-4 下面将对巨型整数的求负进行测试,按任意键继续...... 通过字符串构造一个巨型整数,v1=+1111111111111111111111111111111111111111执行v2=-v1后,v2=-1111111111111111111111111111111111111111通过字符串构造一个巨型整数,v3=-123456789123执行v2=-v3后,v2=+123456789123通过缺省参数构造构造一个巨型整数,v4=+0执行v2=-v4后,v2=+0 下面将对巨型整数的前++、后++、前--、后--进行测试,按任意键继续...... 通过字符串构造一个巨型整数,w1=+9999999999999999999999999999999999执行w2=w1++后,w2=+9999999999999999999999999999999999w1=+10000000000000000000000000000000000通过字符串构造一个巨型整数,x1=-100000000000000执行x2=++x1后,x2=-99999999999999x1=-99999999999999通过字符串构造一个巨型整数,y1=+10000000000000000执行y2=y1--后,y2=+10000000000000000y1=+9999999999999999通过字符串构造一个巨型整数,z1=-99999999999999执行z2=--z1后,z2=-100000000000000z1=-100000000000000Press any key to continue *************************************************************************************************/

博客介绍

正文

巨型整数运算2006-10-06 11:43:00

评论