高精度计算 CPP 类

#define MAXN 1000

//高精度运算类
class BigC
{
public:
        int len,s[MAXN];
        BigC(){memset(s,0,sizeof(s));len=1;}
        BigC(int num){memset(s,0,sizeof(s));*this=num;}
        BigC(const char* num){memset(s,0,sizeof(s));*this=num;}
        BigC(const BigC &num){
            memset(s,0,sizeof(s));
            this->len=num.len;
            for(int i=0;i<=len;i++){
                this->s[i]=num.s[i];
            }
        }
        BigC operator = (const char* num);
        BigC operator = (int num);
        BigC operator = (const BigC num);
        BigC operator + (const BigC& num);
        BigC operator - (int num);
        BigC operator / (int num);
        BigC operator * (int num);
        BigC operator * (const BigC b);
        int operator % (int num);
        int operator > (int num);
        int operator < (int num);
        int operator == (int num);
        int operator != (int num);
        int operator >= (int num);
        long ToInteger();
        string str() const;
};

#define MAX(a,b) (a>b?a:b)

//ConvertToString
string BigC::str() const
{
    string res="";
    for(int i=0;i<len;i++)
    {
        res=(char)(s[i]+'0')+res;
    }
    if(res=="")
    {
        res="0";
    }
    return res;
}

//C++输入输出流重载
//<<
istream& operator >>(istream &in,BigC& x)
{
    string s;
    in>>s;
    x=s.c_str();
    return in;
}

//>>
ostream& operator <<(ostream &out,const BigC& x)
{
    out <<x.str();
    return out;
}

//运算符重载
//=
BigC BigC::operator = (const char* num)
{
    len=strlen(num);
    for(int i=0;i<len;i++)
    {
        s[i]=num[len-i-1]-'0';
    }
    return *this;
}
BigC BigC::operator = (int num)
{
    char s[MAXN];
    sprintf(s,"%d",num);
    *this=s;
    return *this;
}
BigC BigC::operator = (const BigC num)
{
    len=num.len;
    for(int i=0;i<len;i++)
    {
        s[i]=num.s[i];
    }
    return *this;
}

//+
BigC BigC::operator +(const BigC& num)
{
    int carry=0;
    BigC c;
    c.len=0;
    for(int i=0;carryi<MAX(len,num.len);i++)
    {
        carry=s[i]+carry+num.s[i];
        c.s[c.len++]=carry%10;
        carry/=10;
    }
    return c;
}

//-
BigC BigC::operator - (const int num)
{
    int borrow=0;
    BigC b=num;
    BigC c=*this;
    for(int i=0;i<len;i++)
    {
        int d=(s[i]+10)-borrow-b.s[i];
        c.s[i]=d%10;
        borrow=1-d/10;
        if(c.s[c.len-1]==0)
        {
            c.len--;
        }
    }
    return c;
}

//>
int BigC::operator > (int num)
{
    BigC b=num;
    if(len!=b.len)
    {
        return len>b.len;
    }
    for(int i=len-1;i>=0;i--)
    {
        if(s[i]!=b.s[i])
        {
            return s[i]>b.s[i];
        }
    }

    return 0;
}
//<
int BigC::operator < (int num)
{
    BigC b=num;
    if(len!=b.len)
    {
        return len<b.len;
    }
    for(int i=len-1;i>=0;i--)
    {
        if(s[i]!=b.s[i])
        {
            return s[i]<b.s[i];
        }
    }
    return 0;
}

//==
int BigC::operator == (int num)
{
    if(!(*this>num)&&!(*this<num))
    {
        return 1;
    }
    return 0;
}
//!=
int BigC::operator != (int num)
{
    BigC b=num;
    if(len!=b.len)
    {
        return 1;
    }
    else
    {
        for(int i=0;i<len;i++)
        {
            if(s[i]==b.s[i])
            {
                return 0;
            }
        }
        return 1;
    }
}

//>=
int BigC::operator >= (int num)
{
    if((*this>num)(*this==num))
    {
        return 1;
    }
    return 0;
}

//%
int BigC::operator % (int num)
{
    int remain=s[len-1];
    for(int i=len-1;i>0;i--)
    {
        remain%=num;
        remain=s[i-1]+remain*10;
    }
    remain%=num;
    return remain;
}

// 倒置BigC对象
void BackBigC(BigC& quotient)
{
    int t;
    for(int i=0;i<quotient.len/2;i++)
    {
        t=quotient.s[i];
        quotient.s[i]=quotient.s[quotient.len-i-1];
        quotient.s[quotient.len-i-1]=t;
    }
}

// /
BigC BigC::operator / (int num)
{
    BigC quotient=0;
    quotient.len=0;
    int flag=0;
    int t0=s[len-1],t1;
    if(len-1==0)
    {
        quotient=s[0]/num;
        return quotient;
    }
    for(int i=len-1;i>=0;i--)
    {
        if(0==i)
        {   
            t1=t0/num;
            t0%=num;
        }
        else
        {
            t1=t0/num;
            t0%=num;
            t0=s[i-1]+t0*10;
        }
        if(t1!=0)
        {
            flag=1;
        }
        if(flag)
        {
            quotient.s[quotient.len++]=t1;
        }
    }
    if(!flag)
    {
        quotient=0;
        quotient.len=1;
    }
    BackBigC(quotient);
    return quotient;
}

//*
BigC BigC::operator * (const BigC b)
{
    BigC c;
    c.len = len + b.len - 1;//结果的位数最大为两个因子位数之和
    for (int i = 0; i < len; i++)
    for (int j = 0; j < b.len; j++)
        c.s[i + j] += s[i] * b.s[j];//对应位置的积的和，累加起来就是结果
    for (int i = 0; i < c.len - 1; i++)
    {
        c.s[i + 1] += c.s[i] / 10;//进位的值
        c.s[i] %= 10;//余数位
    }
    return c;
}

//ToInteger
long BigC::ToInteger()
{
    long integer=0;
    for(int i=len-1;i>=0;i--)
    {
        integer+=s[len-i-1]*(int)pow((double)10,len-i-1);
    }
    return integer;
}