4.txt

巨型整数类

头文件:   
  #include<iostream.h>   
  class   HugeInt//巨型整数类实现   
  {   
  public:   
          HugeInt(int=0);//用整型初始化巨型整数类对象的构造函数   
          HugeInt(long=0);//用长整型初始化巨型整数类对象的构造函数   
  问题1:         HugeInt(const   char   *,long=0);//用字符串初始化巨型整数类对象的构造函数   
          HugeInt(HugeInt&);//用巨型整数本身初始化巨型整数类对象的构造函数   
          ~HugeInt();//析构函数   
          inline   long   getsize(){return   size;};   
          inline   int   elem(long   index){return   data[index];};   
          HugeInt&   operator   =   (char*);   
          HugeInt&   operator   =   (HugeInt&);   
  private:   
          void   inverse();   
          void   clear();   
          int   inc();   
          int   *data;   
          long   size;   
          friend   ostream&   operator   <<   (ostream&,HugeInt&);   
          friend   HugeInt   operator   +   (HugeInt&,HugeInt&);   
          friend   HugeInt   operator   -   (HugeInt&,HugeInt&);   
          friend   HugeInt   operator   *   (HugeInt&,HugeInt&);   
          friend   HugeInt   operator   /   (HugeInt&,HugeInt&);   
          friend   HugeInt   operator   %   (HugeInt&,HugeInt&);   
          friend   int   add(HugeInt&,HugeInt&,int,int   bitm=0);   
          friend   int   mul(HugeInt&,int);   
          friend   int   div(HugeInt&,HugeInt&,HugeInt&,HugeInt&);   
  具体实现如下:   
  #include<string.h>   
  #include<iomanip.h>   
  #include   "HugeInt.h"   
  #define   ERRORMSG   "Over   Flow!"   
  HugeInt::HugeInt(int   n)   
  {   
          size=(long)n/4;   
          data=new   int[size];   
          for(long   i=0;i<size;++i)data[i]=0;   
  }   
  HugeInt::HugeInt(long   n)   
  {   
          size=n/4;   
          data=new   int[size];   
          for(long   i=0;i<size;++i)data[i]=0;   
  }   
  问题1实现处:HugeInt::HugeInt(const   char   *string,long   n)   
  {   
    size=n/4;   
    long   i,j;   
    for(i=0;i<size;++i)   
      data[i]=0;   
    for(i=size-strlen(string),j=0;i<size;++i,++j)   
    data[i]=string[j]-'0';   
    
  }   
  HugeInt::HugeInt(HugeInt&   a)   
  {   
          size=a.getsize();   
          data=new   int[size];   
          for(long   i=0;i<size;++i)data[i]=a.elem(i);   
  }   
  HugeInt::~HugeInt()   
  {   
          delete[]data;   
  }   
  //private:   
    
  void   HugeInt::inverse()   
  {   
          for(long   i=0;i<size;++i)data[i]=9999-data[i];   
  }   
  void   HugeInt::clear()   
  {   
          for(long   i=0;i<size;++i)data[i]=0;   
  }   
  int   HugeInt::inc()   
  {   
          int   s=1;   
          for(long   i=0;s&&i<size;++i)   
          {   
                  int   t=data[i]+s;   
                  data[i]=t%10000;   
                  s=t/10000;   
          }   
          if(s)return   -1;   
          return   0;   
  }   
  //friends:   
  ostream&   operator   <<(ostream&   out,HugeInt&   a)   
  {   
          int   *p=a.data+a.size-1;   
          while(!*p)--p;   
          out<<*p--;   
          while(p>(a.data-1))   
                  out<<setw(4)<<setfill('0')<<*p--;   
          return   out;   
  }   
  HugeInt&   HugeInt::operator   =   (char   *str)   
  {   
          long   len=strlen(str),count=0;   
          if(len>(size<<2))return   *this;   
          char   *p=str+len-1;   
          int   t,i;   
          while(1)   
          {   
                  if((p-str)<4)break;   
                  t=0;   
                  char   *ph=p-3;   
                  for(int   i=0;i<4;++i)   
                  {   
                          t*=10;   
                          t+=ph[i]-'0';   
                  }   
                  data[count++]=t;   
                  p-=4;   
          }   
          t=0;   
          for(i=0;i<=p-str;++i)   
          {   
                  t*=10;   
                  t+=str[i]-'0';   
          }   
          data[count]=t;   
          return   *this;   
  }   
  HugeInt&   HugeInt::operator   =   (HugeInt&   a)   
  {   
          if(size!=a.getsize())return   *this;   
          for(long   i=0;i<size;++i)data[i]=a.elem(i);   
          return   *this;   
  }   
  HugeInt   operator   +(HugeInt&   a,HugeInt&   b)   
  {   
          HugeInt   temp=a;   
          if(add(temp,b,0))   
                  cerr<<ERRORMSG<<endl;   
          return   temp;   
  }   
  HugeInt   operator   -(HugeInt&   a,HugeInt&   b)   
  {   
          HugeInt   temp1=a,temp2=b;   
          temp2.inverse();   
          add(temp1,temp2,1);   
          return   temp1;   
  }   
  HugeInt   operator   *(HugeInt&   a,HugeInt&   b)   
  {   
          HugeInt   temp1=a,temp2=temp1;   
          temp1.clear();   
          for(long   i=0;i<b.size;++i)   
          {   
                  temp2=a;   
                  mul(temp2,b.data[i]);   
                  add(temp1,temp2,0,i);   
          }   
          return   temp1;   
  }   
  HugeInt   operator   /(HugeInt&   a,HugeInt&   b)   
  {   
          HugeInt   stemp=a,rtemp=a;   
          if(div(a,b,stemp,rtemp))   
                  cerr<<ERRORMSG<<endl;   
          return   stemp;   
  }   
  HugeInt   operator   %(HugeInt&   a,HugeInt&   b)   
  {   
          HugeInt   stemp=a,rtemp=a;   
          if(div(a,b,stemp,rtemp))   
                  cerr<<ERRORMSG<<endl;   
          return   rtemp;   
  }   
  int   add(HugeInt&   a,HugeInt&   b,int   s,int   bitm)   
  {   
          long   size;   
          if((size=a.size)!=b.size)return   -2;   
          for(long   i=bitm;i<size;++i)   
          {   
                  int   t=a.data[i]+b.data[i-bitm]+s;   
                  a.data[i]=t%10000;   
                  s=t/10000;   
          }   
          if(s)return   -1;   
          return   0;   
  }   
  int   mul(HugeInt&   a,int   n)   
  {   
          int   s=0;   
          for(long   i=0;i<a.size;++i)   
          {   
                  long   t=a.data[i]*n+s;   
                  a.data[i]=t%10000;   
                  s=t/10000;   
          }   
          if(s)return   -1;   
          return   0;   
  }   
  int   div(HugeInt&   a,HugeInt&   b,HugeInt&   s,HugeInt&   r)//s=a/b,r=a%b   
  {   
          HugeInt   temp1=a,temp2=b,temp3=a;   
          s.clear();   
          while(1)   
          {   
                  temp2=b;   
                  temp2.inverse();   
                  temp3=temp1;   
                  if(!add(temp1,temp2,1))break;   
                  if(s.inc())return   -1;   
          }   
          r=temp3;   
          return   0;   
  }   
    
  #define   N   1000   
  void   main()   
  {   
          HugeInt   a(N);   
          HugeInt   b=a,c=a;   
  问题1:此处用字符串初始化巨型整数类对象是会出错//HugeInt   n3("999999999999999999",N);   
          a="3000000000000005245225452";   
          b="123432543000005234523424";   
          cout<<a+b<<endl   
                  <<a-b<<endl   
                  <<a*b<<endl   
                  <<a/b<<endl   
                  <<a%b<<endl;   
  //<<n3<<endl;   
  }   
  以上主要有两个问题,一个就是以上我标出的问题1,所在,不知道为什么用字符串初始化巨型整数类对象的时候编译不会出错但是执行就是会出错,我想了半天也弄不明白我的用字符串初始化巨型整数类对象的这个构造函数(即HugeInt(const   char   *,long=0))的实现错在哪里.   
  第二个问题是如果把以上main()函数中的变量a或b的初始值中的一个或两个改成负数程序执行的结果都会出错!我想应该是以上的头文件中的各个函数的实现有问题,但是我想不出如何改进.