巨型整数的运算(绝对原创)

// HugeInt.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include<stdlib.h>
#include<iostream>
#include<string.h>
#include<stdio.h>
#include<math.h>
using namespace std;
int ConvetToInt(char ch)
{
 return ch-48;
}

class HugeInt
{
private:
 short *HugeNum;//存储
 long Length; //巨型整数的长度
 int Sign;    //正负数标志,1表示负数,0表示正数
public:
 HugeInt()
 {
  HugeNum=new short[1];
 }

 //只输入数组的长度来开辟一个内存块
 HugeInt(long lParam)
 {
  Length=lParam;
  Sign=0;
  HugeNum=new short[lParam+1];
  for(int i=0;i<=Length;i++)
  {
   HugeNum[i]=0;
  }
 }

 HugeInt(char *strParam)
 { 
  if(strParam[0]=='-')//设置正负数标志位
  {
   Sign=1;
   //是负数,字符串的第一位表示符号位
   Length=strlen(strParam)-1;
   HugeNum=new short[Length+1];//最高位置0,防止第二位有进位
   HugeNum[0]=0;
   for(int i=1;i<=Length;i++)
   {
    HugeNum[i]=ConvetToInt(strParam[i]);
   }
  }
  else
  {
   Sign=0;
   Length=strlen(strParam);
   HugeNum=new short[Length+1];//最高位置0,防止第二位有进位
   HugeNum[0]=0;
   for(int i=0;i<Length;i++)
   {
    HugeNum[i+1]=ConvetToInt(strParam[i]);//是正数从字符串的第一位开始就是实际有效的数字
   }
  }
 }

    HugeInt(HugeInt &CopyObj)
 {
  //cout<<"调用拷贝构造函数"<<endl;
  if(HugeNum!=NULL)
  {
   HugeNum=NULL;
   delete HugeNum;
  }
  Length=CopyObj.Length;
  HugeNum=new short[Length+1];
  Sign=CopyObj.Sign;
  for(int i=0;i<=Length;i++)
  {
   HugeNum[i]=CopyObj.HugeNum[i];
  }
 } 
 //用数组来初始化
 HugeInt(int *Array,int len)
 {
  Sign=0;
  Length=len;
  HugeNum=new short[len+1];
  HugeNum[0]=0;
  for(int i=0;i<len;i++)
  {
   HugeNum[i+1]=Array[i];
  }
 }
 //获取数字的有效长度
 long GetLength()
 {
  int flag=0;//获得第一个不是0的位置
  while(HugeNum[flag]==0&&flag<Length)
  {
   flag++;
  }
  return Length+1-flag;
 }

 void CreateBySize(long lParam)
 {
  Length=lParam;
  Sign=0;
  HugeNum=new short[lParam+1];
  for(int i=0;i<=Length;i++)
  {
   HugeNum[i]=0;
  }
 }
 //*****************算术运算(加+、减-、乘*、整除/、求余%)****************
 friend HugeInt AdditionAbs  (HugeInt &,HugeInt &);//绝对值相加
 friend HugeInt SubtrationAbs(HugeInt &,HugeInt &);//绝对值相减
 //---------------------加法-------------------------
 friend HugeInt operator+(HugeInt &,HugeInt &);
 friend HugeInt operator+(HugeInt &,long);
 friend HugeInt operator+(HugeInt &,char *);

 //--------------------减法--------------------------
 friend HugeInt operator*(HugeInt &,HugeInt &);
 friend HugeInt operator*(HugeInt &,long);
 friend HugeInt operator*(HugeInt &,char *);

 //-------------------乘法---------------------------
 friend HugeInt operator-(HugeInt &,HugeInt &);
 friend HugeInt operator-(HugeInt &,long);
 friend HugeInt operator-(HugeInt &,char *);

 //-------------------除法---------------------------
 friend HugeInt operator/(HugeInt &,HugeInt &);
 friend HugeInt operator/(HugeInt &,long);
 friend HugeInt operator/(HugeInt &,char *);

 //-------------------取余---------------------------
 friend HugeInt operator%(HugeInt &,HugeInt &);
 friend HugeInt operator%(HugeInt &,long);
 friend HugeInt operator%(HugeInt &,char *);
 //**********************************************************************

 //*********************关系运算(>、>=、<、<=、<>、==)*******************
 int operator > (HugeInt &);
 int operator > (long);
 int operator > (char *);

 int operator >=(HugeInt &);
 int operator >=(long);
 int operator >=(char *);

 int operator < (HugeInt &);
 int operator < (long);
 int operator < (char *);

 int operator <=(HugeInt &);
 int operator <=(long);
 int operator <=(char *);

 int operator !=(HugeInt &);
 int operator !=(long);
 int operator !=(char *);

 int operator ==(HugeInt &);
 int operator ==(long);
 //int operator ==(char);
 //**********************************************************************

 //*********************复合运算(+=、-=、*=、/=、%=)*********************
 void operator +=(HugeInt &AddNum);
 void operator -=(HugeInt &AddNum);
 void operator *=(HugeInt &AddNum);
 void operator /=(HugeInt &AddNum);
 void operator %=(HugeInt &AddNum);
 //**********************************************************************

 //*********************增量运输符++,--**********************************
 HugeInt & operator ++(); //前增量
 HugeInt operator ++(int);//后增量
 HugeInt & operator --(); //前增量
 HugeInt operator --(int);//后增量
 //**********************************************************************

 void operator =(HugeInt &CopyObj);
 int CopmareAbsolute(const HugeInt &CompareObj);//比较两个巨型整数的绝对值大小

 friend ostream& operator << (ostream&,const HugeInt&);
 friend istream& operator >> (istream&,HugeInt&);
 void Print()
 {
  if(HugeNum[0]!=0) cout<<HugeNum[0];
  if(Sign==1)
   cout<<"-";
  for(int i=1;i<=Length;i++)
  {
   cout<<HugeNum[i];
  }
  cout<<endl;
 }

 ~HugeInt()
 {
  delete HugeNum;
 }
};

//*************************************************************************
//                    比较两个巨型整数的绝对值大小
//*************************************************************************
int HugeInt::CopmareAbsolute(const HugeInt &CompareObj)
{
 //flag为大小表记-1表示小于,0表示相等,1表示大于
 int flag=0;
 if(Length>CompareObj.Length)
 {
  flag=1;
  return flag;
 }
 else if(Length < CompareObj.Length)
 {
  flag=-1;
  return flag;
 }
 else if(Length==CompareObj.Length)
 {
  for(int i=1;i<=Length;i++)//从高位比起
  {
   if(HugeNum[i]<CompareObj.HugeNum[i])
   {
    flag=-1;
    break;
   }
   else if(HugeNum[i]>CompareObj.HugeNum[i])
   {
    flag=1;
    break;
   }
  }
  return flag;
 }
}
//*************************************************************************
//                    为了使=可以实现拷贝对象的功能重载=运算符
//*************************************************************************
void HugeInt::operator =(HugeInt &CopyObj)
{
 if(HugeNum!=NULL)
 {
  HugeNum=NULL;
  delete HugeNum;
 }
 Length=CopyObj.Length;
 HugeNum=new short[Length+1];
 Sign=CopyObj.Sign;
 for(int i=0;i<=Length;i++)
 {
  HugeNum[i]=CopyObj.HugeNum[i];
 }
}

//*************************************************************************
//                              重载+=运算符
//*************************************************************************
void HugeInt::operator +=(HugeInt &AddNum)
{
 *this=*this+AddNum;
}

//*************************************************************************
//                              重载-=运算符
//*************************************************************************
void HugeInt::operator -=(HugeInt &SubNum)
{
 *this=*this-SubNum;
}
//*************************************************************************
//                              重载*=运算符
//*************************************************************************
void HugeInt::operator *=(HugeInt &MulNum)
{
 *this=*this*MulNum;
}
//*************************************************************************
//                              重载/=运算符
//*************************************************************************
void HugeInt::operator /=(HugeInt &DivNum)
{
 *this=*this/DivNum;
}

//*************************************************************************
//                              重载%=运算符
//*************************************************************************
void HugeInt::operator %=(HugeInt &ModNum)
{
 *this=(*this)%ModNum;
}
//*************************************************************************
//                    重载关系运算符== 1相等,0不相等
//*************************************************************************
int HugeInt::operator ==(HugeInt &CompareObj)
{
 if(GetLength()!=CompareObj.GetLength()|| Sign!=CompareObj.Sign)
 {
  return 0;
 }
 else
 {
  //标记变量默认为1(相等),从高位比较起,如果出现有一位不相等返回0
  int flag=1;
  for(int i=1;i<=Length;i++)
  {
   if(HugeNum[i]!=CompareObj.HugeNum[i])
   {
    flag=0;
    break;
   }
  }
  return flag;
 }
}

//*************************************************************************
//              重载关系运算符== 1相等,0不相等,以long作为参数
//*************************************************************************
int HugeInt::operator ==(long CompareNum)
{
 char *string=new char[20];
 itoa(CompareNum,string,10);
 HugeInt temp(string);
 return this->operator==(temp);
}

////*************************************************************************
////              重载关系运算符== 1相等,0不相等,以char作为参数
////*************************************************************************
//int HugeInt::operator ==(char *string)
//{
// HugeInt temp(string);
// return this->operator==(temp);
//}

//*************************************************************************
//                         重载关系运算符< 1小于,0不小于
//*************************************************************************
int HugeInt::operator < (HugeInt &CompareObj)
{
 //先判断符号,正数大
 if(Sign==1 && CompareObj.Sign==0)
 {
  return 1;
 }
 else if(Sign==0 && CompareObj.Sign==1)
 {
  return 0;
 }
 else if(Sign==CompareObj.Sign)
 {
  //然后再判断两个对象的长度
  int len=GetLength();
  if(len>CompareObj.GetLength())
  {
   return 0;
  }
  else if(GetLength()<CompareObj.GetLength())
  {
   return 1;
  }
  else if(GetLength()==CompareObj.GetLength())
  {
   //默认是0,从高位开始比较,如果本对象中有一位小于比较的对象就返回1
   int flag=0;
   for(int i=1;i<=Length;i++)
   {

    if(HugeNum[i]<CompareObj.HugeNum[i])
    {
     flag=1;
     return flag;
    }
    //从高位开始比较,如果本对象中有一位大于比较的对象就返回0
    //如果相等就继续比较
    else if(HugeNum[i]>CompareObj.HugeNum[i])
    {
     flag=0;
     return flag;
    }
   }
   return flag;
  }
 }
}

//*************************************************************************
//                 重载关系运算符< 1小于,0不小于,以long作为形参
//*************************************************************************
int HugeInt::operator <(long CompareNum)
{
 char *string=new char[20];
 itoa(CompareNum,string,10);
 HugeInt temp(string);
 return this->operator <(temp);
}

//*************************************************************************
//                 重载关系运算符< 1小于,0不小于,以char作为形参
//*************************************************************************
int HugeInt::operator <(char *string)
{
 HugeInt temp(string);
 return this->operator <(temp);
}

//*************************************************************************
//                    重载关系运算符<= 1大等于,0
//*************************************************************************
int HugeInt::operator <=(HugeInt &CompareObj)
{
 short flag=0;
 if(this->operator <(CompareObj) || this->operator==(CompareObj))
  flag=1;
 return flag;
}

//*************************************************************************
//                    重载关系运算符<= 1大等于,0,以long作为形参
//*************************************************************************
int HugeInt::operator <=(long CompareNum)
{
 char *string=new char[20];
 itoa(CompareNum,string,10);
 HugeInt temp(string);
 return this->operator <=(temp);
}

//*************************************************************************
//                    重载关系运算符<= 1大等于,0,以char作为形参
//*************************************************************************
int HugeInt::operator <=(char *string)
{
 HugeInt temp(string);
 return this->operator <=(temp);
}

//*************************************************************************
//                    重载关系运算符>, 1大于,0不大于
//*************************************************************************
int HugeInt::operator > (HugeInt &CompareObj)
{
 short flag=0;
 //如果不小等于,就是大于
 if(!this->operator >(CompareObj))
  flag=1;
 return flag;
}

//*************************************************************************
//                    重载关系运算符>, 1大于,0不大于以long为形参
//*************************************************************************
int HugeInt::operator > (long CompareNum)
{
 char *string=new char[20];
 itoa(CompareNum,string,10);
 HugeInt temp(string);
 return this->operator >(temp);
}

//*************************************************************************
//                    重载关系运算符>, 1大于,0不大于以char为形参
//*************************************************************************
int HugeInt::operator > (char *string)
{
 HugeInt temp(string);
 return this->operator >(temp);
}

//*************************************************************************
//                    重载关系运算符>=, 1大等于,0不大等于
//*************************************************************************
int HugeInt::operator >=(HugeInt &CompareObj)
{
 short flag=0;
 //如果不小等于,就是大于
 if(this->operator>(CompareObj)&&this->operator ==(CompareObj))
  flag=1;
 return flag;
}

//*************************************************************************
//                    重载关系运算符>=, 1大等于,0不大等于,以long作为形参
//*************************************************************************
int HugeInt::operator >=(long CompareNum)
{
 char *string=new char[20];
 itoa(CompareNum,string,10);
 HugeInt temp(string);
 return this->operator >=(temp);
}

//*************************************************************************
//                    重载关系运算符>=, 1大等于,0不大等于,以char作为形参
//*************************************************************************
int HugeInt::operator >=(char *string)
{
 HugeInt temp(string);
 return this->operator >=(temp);
}

//*************************************************************************
//                    重载关系运算符!=, 1大等于,0不大等于
//*************************************************************************
int HugeInt::operator !=(HugeInt &CompareObj)
{
 return !(this->operator ==(CompareObj));
}

//*************************************************************************
//                    重载关系运算符!=, 1大等于,0不大等于,以long作为形参
//*************************************************************************
int HugeInt::operator !=(long CompareNum)
{
 char *string=new char[20];
 itoa(CompareNum,string,10);
 HugeInt temp(string);
 return this->operator !=(temp);
}

//*************************************************************************
//                    重载关系运算符!=, 1大等于,0不大等于,以char作为形参
//*************************************************************************
int HugeInt::operator !=(char *string)
{
 HugeInt temp(string);
 return this->operator !=(temp);
}
//*************************************************************************
//                               绝对值相加
//*************************************************************************
HugeInt AdditionAbs(HugeInt &AddNum1,HugeInt &AddNum2)
{
 
 int i,j;
 HugeInt Result;
 short *CarryFlag;//进位标志
 if(AddNum1.Length>=AddNum2.Length)
 {
  Result=AddNum1;
  CarryFlag=new short[Result.Length+1];
  for(i=0;i<=Result.Length;i++)
   CarryFlag[i]=0;
  for(i=AddNum1.Length,j=AddNum2.Length;i>=0;i--,j--)
  {
   if(j>=0)
    Result.HugeNum[i]=Result.HugeNum[i]+AddNum2.HugeNum[j]+CarryFlag[i];
   else
    Result.HugeNum[i]=Result.HugeNum[i]+CarryFlag[i];
   //给上一位的进位标志赋值,如果加的结果超过10则进位标志设为1
   CarryFlag[i-1]=Result.HugeNum[i]/10;
   Result.HugeNum[i]=Result.HugeNum[i]%10;
  }
 }
 else
 {
  Result=AddNum2;
  CarryFlag=new short[Result.Length+1];
  for(i=0;i<=Result.Length;i++)
   CarryFlag[i]=0;
  for(i=AddNum2.Length,j=AddNum1.Length;i>=0;i--,j--)
  {
   if(j>=0)
    Result.HugeNum[i]=Result.HugeNum[i]+AddNum1.HugeNum[j]+CarryFlag[i];
   else
    Result.HugeNum[i]=Result.HugeNum[i]+CarryFlag[i];
   CarryFlag[i-1]=Result.HugeNum[i]/10;
   Result.HugeNum[i]=Result.HugeNum[i]%10;
  }
 }
// delete(CarryFlag);
 return Result;
}
//*************************************************************************
//                               绝对值相减
//*************************************************************************
HugeInt SubtrationAbs(HugeInt &AddNum1,HugeInt &AddNum2)
{
 int i,j;
 HugeInt Result;
 int *CarryFlag;//进位标志
 Result=AddNum1;
 CarryFlag=new int[Result.Length+1];
 for(i=0;i<=Result.Length;i++)
  CarryFlag[i]=0;
 for(i=AddNum1.Length,j=AddNum2.Length;i>=1;i--,j--)
 {
  //如果AddNum2[i]的值比AddNum1[i]减去它的进位标记的值大,就向前借一位
  int temp=0;
  if(j>=1) temp=AddNum2.HugeNum[j];
  if((AddNum1.HugeNum[i]-CarryFlag[i])<temp)
  {
   if(j>=1)
    Result.HugeNum[i]=10+AddNum1.HugeNum[i]-AddNum2.HugeNum[j]-CarryFlag[i];
   else
    Result.HugeNum[i]=10+AddNum1.HugeNum[i]-CarryFlag[i];
   CarryFlag[i-1]=1;
   Result.HugeNum[i]=Result.HugeNum[i]%10;
  }
  else
  {
   if(j>=1)
    Result.HugeNum[i]=AddNum1.HugeNum[i]-AddNum2.HugeNum[j]-CarryFlag[i];
   else
    Result.HugeNum[i]=AddNum1.HugeNum[i]-CarryFlag[i];
  }
 }
 //如果第1位产生0,就要进行移位
 if(Result.HugeNum[1]==0)
 {
  for(i=1;i<=Result.Length;i++)
   Result.HugeNum[i]=Result.HugeNum[i+1];
  Result.Length--;
 }
 return Result;
}
//*************************************************************************
//                         重载加法运算符
//*************************************************************************
HugeInt operator +(HugeInt &AddNum1,HugeInt &AddNum2)
{
 //判断结果的正负号
 HugeInt Result;
 if(AddNum1.Sign==0 && AddNum2.Sign==0)
 {
  Result=AdditionAbs(AddNum1,AddNum2);
  Result.Sign=0;
 }
 else if(AddNum1.Sign==1 && AddNum2.Sign==1)
 {
  Result=AdditionAbs(AddNum1,AddNum2);
  Result.Sign=1;
 }
 else if(AddNum1.Sign==1 && AddNum2.Sign==0)//两加数异号
 {
  int i=AddNum1.CopmareAbsolute(AddNum2);//比较哪个数的绝对值大
  if(i==1)
  {
   Result=SubtrationAbs(AddNum1,AddNum2);
   Result.Sign=1;
  }
  else if(i==-1)
  {
   Result=SubtrationAbs(AddNum2,AddNum1);
   Result.Sign=0;
  }
  else if(i==0)
  {
   Result=HugeInt("0");
  }
 }
 else if(AddNum1.Sign==0 && AddNum2.Sign==1)
 {
  int i=AddNum1.CopmareAbsolute(AddNum2);//比较哪个数的绝对值大
  if(i==1)
  {
   Result=SubtrationAbs(AddNum1,AddNum2);
   Result.Sign=0;
  }
  else if(i==-1)
  {
   Result=SubtrationAbs(AddNum2,AddNum1);
   Result.Sign=1;
  }
  else if(i==0)
  {
   Result=HugeInt("0");
  }
 }
 return Result;
}

//*************************************************************************
//                         重载加法运算符,long为行参
//*************************************************************************
HugeInt operator +(HugeInt &AddNum1,long Num)
{
 char *string=new char[20];
 itoa(Num,string,10);
 HugeInt temp(string);
 return AddNum1+temp;
}

//*************************************************************************
//                         重载加法运算符(char)
//*************************************************************************
HugeInt operator +(HugeInt &AddNum1,char *string)
{
 HugeInt temp(string);
 return AddNum1+temp;
}

//*************************************************************************
//                         重载减法运算符
//*************************************************************************
HugeInt operator -(HugeInt &SubNum1,HugeInt &SubNum2)
{
 HugeInt Result;
 if(SubNum1.Sign==0 && SubNum2.Sign==1)
 {
  //被减数为正，减数为负，调用绝对值相加，结果必为正
  Result=AdditionAbs(SubNum1,SubNum2);
  Result.Sign=0;
 }
 else if(SubNum1.Sign==1 && SubNum2.Sign==0)
 {
  //被减数为负，减数为正，调用绝对值相加，结果必为负
  Result=AdditionAbs(SubNum1,SubNum2);
  Result.Sign=1;
 }
 else if(SubNum1.Sign==1 && SubNum2.Sign==1)
 {
  //被减数为负，减数为负，调用绝对值减法，
  //结果的符号取自绝对值大的数
  int i=SubNum1.CopmareAbsolute(SubNum2);
  if(i==1)
  {
   Result=SubtrationAbs(SubNum1,SubNum2);
   Result.Sign=1;
  }
  else if(i==-1)
  {
   Result=SubtrationAbs(SubNum2,SubNum1);
   Result.Sign=0;
  }
  else if(i==0)
  {
   Result=HugeInt("0");
  }
 }
 else if(SubNum1.Sign==0 && SubNum2.Sign==0)
 {
  int i=SubNum1.CopmareAbsolute(SubNum2);
  if(i==1)
  {
   Result=SubtrationAbs(SubNum1,SubNum2);
   Result.Sign=0;
  }
  else if(i==-1)
  {
   Result=SubtrationAbs(SubNum2,SubNum1);
   Result.Sign=1;
  }
  else if(i==0)
  {
   Result=HugeInt("0");
  }
 }
 return Result;
}

//*************************************************************************
//                         重载减法运算符,long为行参
//*************************************************************************
HugeInt operator -(HugeInt &SubNum1,long Num)
{
 char *string=new char[20];
 itoa(Num,string,10);
 HugeInt temp(string);
 return SubNum1-temp;
}

//*************************************************************************
//                         重载减法运算符(char)
//*************************************************************************
HugeInt operator -(HugeInt &SubNum1,char *strParam)
{
 HugeInt temp(strParam);
 return SubNum1-temp;
}

//*************************************************************************
//                           重载乘法运算符
//*************************************************************************
HugeInt operator *(HugeInt &MulNum1,HugeInt &MulNum2)//MulNum1被乘数,MulNum2乘数
{
 int i,j;//循环变量
 //两个数的乘积的长度是两个数的长度和
 int len=MulNum1.Length+MulNum2.Length;
 HugeInt Result(len);
 short CarryFlag=0;
 //先把乘数由低位开始,每位都与被乘数相乘
 //每次乘后的结果都放在Result中;
 for(i=MulNum2.Length;i>0;i--)
 {
  //临时对象用来存放每次乘法时每一位的乘积
  HugeInt temp(Result.Length);
  long sub=Result.Length-MulNum1.Length;//结果和被乘数的差,用来决定一位乘法结果的位置
  for(j=MulNum1.Length;j>=0;j--)
  {
   temp.HugeNum[sub+j]=MulNum1.HugeNum[j]*MulNum2.HugeNum[i]+CarryFlag;
   CarryFlag=temp.HugeNum[sub+j]/10;
   temp.HugeNum[sub+j]=temp.HugeNum[sub+j]%10;
  }
  //下向前移一位
  int k;//循环变量,用来表示要向前移多少位
  k=MulNum2.Length-i;
  long Start=temp.Length-temp.GetLength()+1;
  while(Start<=temp.Length)
  {
   temp.HugeNum[Start-k]=temp.HugeNum[Start];
   Start++;
  }

  for(;k>0;k--)
  {
   temp.HugeNum[temp.Length-k+1]=0;
  }
  Result+=temp;
 }
 //如果结果的第一位是0,将结果前面的1个0除去
 if(Result.HugeNum[1]==0)
 {
  for(int i=2;i<=Result.Length;i++)
  {
   Result.HugeNum[i-1]=Result.HugeNum[i];
  }
  Result.Length--;
 }
 if(MulNum1.Sign!=MulNum2.Sign)
  Result.Sign=1;
 return Result;
}

//*************************************************************************
//                         重载乘法运算符,long为行参
//*************************************************************************
HugeInt operator *(HugeInt &MulNum1,long Num)
{
 char *string=new char[20];
 itoa(Num,string,10);
 HugeInt temp(string);
 return MulNum1*temp;
}

//*************************************************************************
//                         重载乘法运算符(char)
//*************************************************************************
HugeInt operator *(HugeInt &MulNum1,char *string)
{
 HugeInt temp(string);
 return MulNum1*temp;
}

//*************************************************************************
//                               重载除法运算符
//*************************************************************************
HugeInt  operator / (HugeInt &DivNum1,HugeInt &DivNum2)
{
 //如果除数比被除数大,直接返回0
 HugeInt tempNum2=DivNum2;
 tempNum2.Sign=0;
 if((DivNum1.CopmareAbsolute(DivNum2))==-1)
 {
  HugeInt divResult("0");
  return divResult;
 }
 //如果除数是0,返回错误
 if(DivNum2==0l)
 {
  cerr<<"除数不能是0!"<<endl;
  exit(1);
 }
 //商的长度
 long len=DivNum1.Length-DivNum2.Length;
 HugeInt divResult;//除的结果
 divResult.CreateBySize(len+1);
 HugeInt preNewDiv=DivNum1;//每次新的被除數
 preNewDiv.Sign=0;
 HugeInt preQuotient;   //每次求得的商
 HugeInt preMul;           //除数于每次求得的商的乘积

 for(int i=DivNum1.Length-DivNum2.Length;i>=0;i--)
 {
  //用来初始化每次求得商
  //第一位是1,后面都是0,
  char *str=new char[i+1];
  str[0]='1';
  for(int k=1;k<i+1;k++)
   str[k]='0';
  str[i+1]='/0';
  int j=0;
  for(j=1;j<=9;j++)
  {
   preQuotient=HugeInt(str);
   ////cout<<"preMul:     ";
   preMul=preQuotient*tempNum2;
   //preMul.Print();
   //cout<<"preQuotient:";preQuotient.Print(); 
   //cout<<(preMul<=preNewDiv);
   //cout<<endl;
   if(preMul<=preNewDiv)
   //如果每次乘积小于被除数,被除数减去一次的乘积得到一个新的被除数
   {
    divResult.HugeNum[len-i+1]+=1;//对应的商加1  
    preNewDiv=preNewDiv-preMul; //每次得到一个新的被除数相当于除数乘以商与被除数的差
    //cout<<"preNewDiv   ";preNewDiv.Print(); cout<<endl;
   }
   else
    break;
   
  }
 }
 if(DivNum1.Sign==DivNum2.Sign)
 {
  divResult.Sign=0;
 }
 else
 {
  divResult.Sign=1;
 }
 return divResult;
}

//*************************************************************************
//                         重载除法运算符(char)
//*************************************************************************
HugeInt operator /(HugeInt &DivNum1,char *string)
{
 HugeInt temp(string);
 return DivNum1/temp;
}

//*************************************************************************
//                         重载除法运算符,long为行参
//*************************************************************************
HugeInt operator /(HugeInt &DivNum1,long Num)
{
 char *string=new char[20];
 itoa(Num,string,10);
 HugeInt temp(string);
 return DivNum1/temp;
}

//*************************************************************************
//                               重载取mod运算符
//*************************************************************************
HugeInt operator %(HugeInt &ModNum1,HugeInt &ModNum2)
{
 HugeInt Div=ModNum1/ModNum2;//商
 HugeInt Mul=ModNum2*Div;
 HugeInt Result;
 Result=ModNum1-Mul;
 return Result;
}

//*************************************************************************
//                         重载mod运算符(char)
//*************************************************************************
HugeInt operator %(HugeInt &ModNum1,char *string)
{
 HugeInt temp(string);
 return ModNum1%temp;
}

//*************************************************************************
//                         重载mod运算符,long为行参
//*************************************************************************
HugeInt operator %(HugeInt &ModNum1,long Num)
{
 char *string=new char[20];
 itoa(Num,string,10);
 HugeInt temp(string);
 return ModNum1%temp;
}

//*************************************************************************
//                           重载前增量++运算符
//*************************************************************************
HugeInt & HugeInt::operator ++()
{
 HugeInt Add("1");
 (*this)+=Add;
 return *this;
}

//*************************************************************************
//                               重载后增量++运算符
//*************************************************************************
HugeInt HugeInt::operator ++(int)
{
 HugeInt temp(*this);
 HugeInt Add("1");
 (*this)+=Add;
 return temp;
}

//*************************************************************************
//                               重载前增量--运算符
//*************************************************************************
HugeInt & HugeInt::operator --()
{
 HugeInt Add("-1");
 (*this)+=Add;
 return *this;
}

//*************************************************************************
//                               重载后增量--运算符
//*************************************************************************
HugeInt HugeInt::operator --(int)
{
 HugeInt temp(*this);
 HugeInt Add("-1");
 (*this)+=Add;
 return temp;
}

ostream& operator << (ostream& os,const HugeInt& obj)
{
 if(obj.HugeNum[0]!=0) os<<obj.HugeNum[0];
 if(obj.Sign==1)
  os<<"-";
 for(int i=1;i<=obj.Length;i++)
 {
  os<<obj.HugeNum[i];
 }
 return os;
}

istream& operator >> (istream& is, HugeInt& obj)
{
 char *temp=new char[1000];
 is>>temp;
 obj=HugeInt(temp);
 return is;
}