基于C++的大整数运算操作

主要思想是模拟手算，不知道还有没有未发现的bug，若有错误，希望各位不吝赐教。

#include <iostream>
#include <cstring>
using namespace std;
#define maxn 5005

class BigInteger
{
private:
    int len;    //记录数据实际长度
    int data[maxn]; //记录数据，低位在前，高位在后
    bool positive;  //标记正或负
private:
    void toInt(char *);
    void toStr(char *);
    BigInteger plus(BigInteger a);
    BigInteger minus(BigInteger a);
public:
    BigInteger();
    BigInteger(char *s);
    BigInteger(int a);
    friend istream& operator >> (istream &in, BigInteger &a);
    friend ostream& operator << (ostream &out, BigInteger &a);
    BigInteger operator + (BigInteger a);
    BigInteger operator + (int a);
    BigInteger operator - (BigInteger a);
    BigInteger operator - (int a);
    BigInteger operator * (BigInteger a);
    BigInteger operator * (int a);
    BigInteger operator / (BigInteger a);
    BigInteger operator / (int a);
    BigInteger operator % (BigInteger a);
    int operator % (int a);
    void operator = (int a);
    void operator = (BigInteger a);
    bool operator < (BigInteger a);
    bool operator < (int a);
    bool operator <= (BigInteger a);
    bool operator <= (int a);
    bool operator > (BigInteger a);
    bool operator > (int a);
    bool operator >= (BigInteger a);
    bool operator >= (int a);
    bool operator == (BigInteger a);
    bool operator == (int a);
};

BigInteger :: BigInteger()
{
    memset(data, 0, sizeof(data));
    positive = true;
    len = 0;
};

BigInteger :: BigInteger(char *s)
{
    len = strlen(s);
    toInt(s);
}

BigInteger :: BigInteger(int a)
{
    int i;
    memset(this->data, 0, sizeof(this->data));
    if(a<0 this-="">positive = false;
    else this->positive = true;
    for(i=0; a; i++)
    {
        data[i] = a % 10;
        a = a / 10;
    }
    this->len = i;
}

void BigInteger :: operator = (int a)
{
    int i;
    memset(this->data, 0, sizeof(this->data));
    if(a<0 this-="">positive = false;
    else this->positive = true;
    for(i=0; a; i++)
    {
        data[i] = a % 10;
        a = a / 10;
    }
    this->len = i;
}

void BigInteger :: operator = (BigInteger a)
{
    memset(this->data, 0, sizeof(this->data));
    for(int i=0; i<a len="" i="" this-="">data[i] = a.data[i];
    }
    this->positive = a.positive;
    this->len = a.len;
}

void BigInteger :: toInt(char *s)
{
    memset(data, 0, sizeof(data));
    int i=0, l=len;
    if(s[i]=='-') {positive = false; i++; len--;}
    else positive = true;
    for(int j=0; i<l; i++, j++)
    {
        data[j] = s[l - j -1] - '0';
    }
}

void BigInteger :: toStr(char *s)
{
    int j=0;
    if(!len) s[j++]='0';
    if(len && !positive) s[j++]='-';
    for(int i=0; i<len i="" s="" j="" data="" len="" -="" i="" -1="" 0="" s="" j="" 0="" istream="" operator="">> (istream &in, BigInteger &a)
{
    char str[maxn];
    in >> str;
    a.len = strlen(str);
    a.toInt(str);
    return in;
}

ostream& operator << (ostream &out, BigInteger &a)
{
    char str[maxn];
    a.toStr(str);
    out << str;
    return out;
}

bool BigInteger :: operator < (BigInteger a)
{
    bool positive = true;
    if(this->positive && !a.positive) return false;
    else if(!this->positive && a.positive) return true;
    else if(!this->positive && !a.positive) positive = false;

    if(this->len < a.len) return positive;
    else if(this->len > a.len) return !positive;
    for(int i=len-1; i>=0; i--)
    {
        if(data[i]<a data="" i="" return="" positive="" if="" data="" i="">a.data[i]) return !positive;
    }
    return false;
}

bool BigInteger :: operator < (int a)
{
    bool positive = true;
    if(this->positive && a<0 return="" false="" else="" if="" this-="">positive && a>0) return true;
    if(!this->positive && a<=0) positive = false;

    if(len>10) return !positive;
    else
    {
        int n[11], i=0;
        while(a)
        {
            n[i++] = a%10;
            a /= 10;
        }
        if(i > len) return positive;
        else if(i < len) return !positive;
        else
        {
            for(i=len-1; i>=0; i--)
            {
                if(data[i]<n i="" return="" positive="" if="" data="" i="">n[i]) return !positive;
            }
        }
    }
    return false;
}

bool BigInteger :: operator <= (BigInteger a)
{
    bool positive = true;
    if(this->positive && !a.positive) return false;
    else if(!this->positive && a.positive) return true;
    else if(!this->positive && !a.positive) positive = false;

    if(this->len < a.len) return positive;
    else if(this->len > a.len) return !positive;
    for(int i=len-1; i>=0; i--)
    {
        if(data[i]<a data="" i="" return="" positive="" if="" data="" i="">a.data[i]) return !positive;
    }
    return true;
}

bool BigInteger :: operator <= (int a)
{
    bool positive = true;
    if(this->positive && a<0 return="" false="" else="" if="" this-="">positive && a>0) return true;
    if(!this->positive && a<=0) positive = false;

    if(len>10) return !positive;
    else
    {
        int n[11], i=0;
        while(a)
        {
            n[i++] = a%10;
            a /= 10;
        }
        if(i > len) return positive;
        else if(i < len) return !positive;
        else
        {
            for(i=len-1; i>=0; i--)
            {
                if(data[i]<n i="" return="" positive="" if="" data="" i="">n[i]) return !positive;
            }
        }
    }
    return true;
}

bool BigInteger :: operator > (BigInteger a)
{
    bool positive = true;
    if(this->positive && !a.positive) return true;
    else if(!this->positive && a.positive) return false;
    else if(!this->positive && !a.positive) positive = false;

    if(this->len < a.len) return !positive;
    else if(this->len > a.len) return positive;
    for(int i=len-1; i>=0; i--)
    {
        if(data[i]<a data="" i="" return="" positive="" if="" data="" i="">a.data[i]) return positive;
    }
    return false;
}

bool BigInteger :: operator > (int a)
{
    bool positive = true;
    if(this->positive && a<0 return="" true="" else="" if="" this-="">positive && a>0) return false;
    if(!this->positive && a<=0) positive = false;

    if(len>10) return positive;
    else
    {
        int n[11], i=0;
        while(a)
        {
            n[i++] = a%10;
            a /= 10;
        }
        if(i > len) return !positive;
        else if(i < len) return positive;
        else
        {
            for(i=len-1; i>=0; i--)
            {
                if(data[i]<n i="" return="" positive="" if="" data="" i="">n[i]) return positive;
            }
        }
    }
    return false;
}

bool BigInteger :: operator >= (BigInteger a)
{
    bool positive = true;
    if(this->positive && !a.positive) return true;
    else if(!this->positive && a.positive) return false;
    else if(!this->positive && !a.positive) positive = false;

    if(this->len < a.len) return !positive;
    else if(this->len > a.len) return positive;
    for(int i=len-1; i>=0; i--)
    {
        if(data[i]<a data="" i="" return="" positive="" if="" data="" i="">a.data[i]) return positive;
    }
    return true;
}

bool BigInteger :: operator >= (int a)
{
    bool positive = true;
    if(this->positive && a<0 return="" true="" else="" if="" this-="">positive && a>0) return false;
    if(!this->positive && a<=0) positive = false;

    if(len>10) return positive;
    else
    {
        int n[11], i=0;
        while(a)
        {
            n[i++] = a%10;
            a /= 10;
        }
        if(i > len) return !positive;
        else if(i < len) return positive;
        else
        {
            for(i=len-1; i>=0; i--)
            {
                if(data[i]<n i="" return="" positive="" if="" data="" i="">n[i]) return positive;
            }
        }
    }
    return true;
}

bool BigInteger :: operator == (BigInteger a)
{
    if(this->positive ^ a.positive) return false;
    if(this->len != a.len) return false;
    for(int i=0; i<a len="" i="" if="" this-="">data[i]!=a.data[i]) return false;
    }
    return true;
}

bool BigInteger :: operator == (int a)
{
    if(this->len > 10) return false;
    if(this->positive ^ a>0) return false;
    if(a==0 && !this->positive && this->len==1 && !this->data[0]) return true;
    int j = 0;
    int n[11] = {0};
    while(a)
    {
        n[j++] = a%10;
        a /= 10;
    }
    if(this->len != j) return false;
    else
    {
        for(int i = this->len-1, j=0; i>=0; i--, j++)
        {
            if(this->data[i]!=n[j]) return false;
        }
    }
    return true;
}

BigInteger BigInteger :: operator + (BigInteger a)
{
    BigInteger b;
    if(this->positive && a.positive)
    {
        b = (*this).plus(a);
    }
    if(!this->positive && !a.positive)
    {
        b = (*this).plus(a);
        b.positive = false;
    }
    if(this->positive && !a.positive)
    {
        b = (*this).minus(a);
    }
    if(!this->positive && a.positive)
    {
        b = a.minus(*this);
    }
    return b;
}

BigInteger BigInteger :: operator + (int a)
{
    BigInteger b = a;
    if(this->positive && b.positive)
    {
        b = (*this).plus(b);
    }
    if(!this->positive && !b.positive)
    {
        b = (*this).plus(b);
        b.positive = false;
    }
    if(this->positive && !b.positive)
    {
        b = (*this).minus(b);
    }
    if(!this->positive && b.positive)
    {
        b = b.minus(*this);
    }
    return b;
}

BigInteger BigInteger :: operator - (BigInteger a)
{
    BigInteger b;
    if(this->positive && a.positive)
    {
        b = (*this).minus(a); //正负根据返回而定，浅拷贝
    }
    if(this->positive && !a.positive)
    {
        b = (*this).plus(a);  //默认为正数
    }
    if(!this->positive && a.positive)
    {
        b = (*this).plus(a);
        b.positive = false;  //负数减正数结果为负
    }
    if(!this->positive && !a.positive)
    {
        b = a.minus(*this);
    }
    return b;
}

BigInteger BigInteger :: operator - (int a)
{
    BigInteger b = a;
    if(this->positive && b.positive)
    {
        b = (*this).minus(b); //正负根据返回而定，浅拷贝
        return b;
    }
    if(this->positive && !b.positive)
    {
        b = (*this).plus(b);  //默认为正数
        return b;
    }
    if(!this->positive && b.positive)
    {
        b = (*this).plus(b);
        b.positive = false;  //负数减正数结果为负
        return b;
    }
    if(!this->positive && !b.positive)
    {
        b = b.minus(*this);
        return b;
    }
    return b;
}

BigInteger BigInteger :: plus(BigInteger a)
{
    BigInteger b;
    int carry=0;
    for(int i=0; i<=len || i<=a.len; i++)
    {
        b.data[i] = data[i] + a.data[i] + carry;
        carry = b.data[i] / 10;
        b.data[i] = b.data[i] % 10;
    }
    for(b.len=maxn-1; b.len>=0 && !b.data[b.len]; b.len--);
    b.len++;
    return b;
}

BigInteger BigInteger :: minus(BigInteger a)
{
    BigInteger b, *t1 = this, *t2= &a;
    bool bigger = true, borrow = false;
    if(*this < a) {bigger = false; t1 = &a; t2 = this;}
    int n = t1->data[0];
    for(int i=0; i<t1->len; i++)
    {
        if(n<t2->data[i]) {n = n + 10; borrow = true;}
        b.data[i] = n - t2->data[i];
        if(borrow) {n = t1->data[i+1] - 1; borrow = false;}
        else n = t1->data[i+1];
    }
    for(b.len=t1->len; b.len>=0 && !b.data[b.len]; b.len--);
    b.len++;
    if(!bigger) b.positive = false;
    return b;
}

BigInteger BigInteger :: operator * (BigInteger a)
{
    BigInteger b; int n;
    if((this->positive && !a.positive) || (!this->positive && a.positive)) b.positive=false;
    for(int i=0; i<this->len; i++)
    {
        for(int j=0; j<a len="" j="" n="b.data[i" j="" this-="">data[i] * a.data[j];
            b.data[i + j + 1] = b.data[i + j + 1] + n/10;
            b.data[i + j] = n%10;
        }
    }
    for(b.len=maxn-1; b.len>=0 && !b.data[b.len]; b.len--);
    b.len++;
    return b;
}

BigInteger BigInteger :: operator * (int a)
{
    BigInteger b; int n;
    if(a<0 b="" positive="!this-">positive;
    for(int i=0; i<maxn i="" n="b.data[i]" a="" data="" i="" b="" data="" i="" 1="" b="" data="" i="" 1="" n="" 10="" b="" data="" i="" n="" 10="" for="" b="" len="maxn-1;" b="" len="">=0 && !b.data[b.len]; b.len--);
    b.len++;
    return b;
}

BigInteger BigInteger :: operator / (BigInteger a)
{
    BigInteger res, dividend = *this, divisor = a, temp; int m, n; //dividend被除数， divisor除数
    if((this->positive && !a.positive) || (!this->positive && a.positive)) res.positive=false;
    if(this->len < a.len) return res;
    while(a < dividend || a==dividend)
    {
        divisor = a;
        temp = 1;
        for(int i=divisor.len; i<dividend.len-1; i++)
        temp = temp * 10;
        divisor = divisor * temp;
        while(divisor < dividend || dividend == divisor)
        {
            res = res + temp;
            dividend = dividend - divisor;
        }
    }
    return res;
}

BigInteger BigInteger :: operator / (int a)
{
    BigInteger res;
    int t=0;
    if(a<0 res="" positive="(!this-">positive);
    else res.positive = this->positive;
    for(int i=this->len; i>=0; i--)
    {
        t = t * 10+this->data[i];
        res.data[i] = t / a;
        t = t % a;
    }
    for(res.len=maxn-1; res.len>=0 && !res.data[res.len]; res.len--);
    res.len++;
    return res;
}

int BigInteger :: operator % (int a)
{
    int t=0;
    for(int i=this->len; i>=0; i--)
    {
        t = t * 10 + this->data[i];
        t = t % a;
    }
    return t;
}

BigInteger BigInteger :: operator % (BigInteger a)
{
    BigInteger dividend = *this, divisor = a, temp; //dividend被除数， divisor除数
    if(this->len < a.len) return *this;
    while(a < dividend || a==dividend)
    {
        divisor = a;
        temp = 1;
        for(int i=divisor.len; i<dividend.len-1; i++)
        temp = temp * 10;
        divisor = divisor * temp;
        while(divisor < dividend || dividend == divisor)
        {
            dividend = dividend - divisor;
        }
    }
    return dividend;
}