代码

#include<bits/stdc++.h>
using namespace std;
#define L 2000005//每一个数的最大位数
class bignum
{
    public:
        int len,s[L];
        bignum();
        bignum(const char*);
        bignum(int);
        bool sign;//负数判断
        string toStr() const;//转换成字符串
        friend istream&operator>>(istream&,bignum&);//输入重定向
        friend ostream&operator<<(ostream&,bignum&);//输出重定向
        bignum operator=(const char*);//重载运算符
        bignum operator=(int);
        bignum operator=(const string);
        bool operator>(const bignum&) const;//关系运算符
        bool operator>=(const bignum&) const;
        bool operator<(const bignum&) const;
        bool operator<=(const bignum&) const;
        bool operator==(const bignum&) const;
        bool operator!=(const bignum&) const;
        bignum operator+(const bignum&) const;//四则运算
        bignum operator++();
        bignum operator++(int);
        bignum operator+=(const bignum&);
        bignum operator-(const bignum&) const;
        bignum operator--();
        bignum operator--(int);
        bignum operator-=(const bignum&);
        bignum operator*(const bignum&) const;
        bignum operator*(const int num) const;
        bignum operator*=(const bignum&);
        bignum operator/(const bignum&) const;
        bignum operator/=(const bignum&);
        bignum operator%(const bignum&) const;//衍生运算
        bignum factorial() const;
        bignum Sqrt() const;
        bignum Pow(const bignum&) const;
        void clean();
        ~bignum();
};
#define max(a,b) a>b?a:b
#define min(a,b) a<b?a:b

//初始化
bignum::bignum()
{
    memset(s,0,sizeof(s));
    len=1;
    sign=1;
}

bignum::bignum(const char*num)
{
    *this=num;
}

bignum::bignum(int num)
{
    *this=num;
}

string bignum::toStr() const
{
    string res;
    res="";
    for(int i=0;i<len;i++)
        res=(char)(s[i]+'0')+res;
    if(res=="")
        res="0";
    if(!sign&&res!="0")
        res="-"+res;
    return res;
}

istream&operator>>(istream&in,bignum&num)
{
    string str;
    in>>str;
    num=str;
    return in;
}

ostream&operator<<(ostream&out,bignum&num)
{
    out<<num.toStr();
    return out;
}

bignum bignum::operator=(const char*num)
{
    memset(s,0,sizeof(s));
    char a[L]="";
    if(num[0]!='-')
        strcpy(a,num);
    else
    {
        int numlen=strlen(num);
        for(int i=1;i<numlen;i++)
            a[i-1]=num[i];
    }
    sign=!(num[0]=='-');
    len=strlen(a);
    for(int i=0;i<len;i++)
        s[i]=a[len-i-1]-48;
    return *this;
}

bignum bignum::operator=(int num)
{
    if(num<0)
        sign=0,num=-num;
    else
        sign=1;
    char temp[L];
    sprintf(temp,"%d",num);
    *this=temp;
    return *this;
}
bignum bignum::operator=(const string num)
{
    const char*tmp;
    tmp=num.c_str();
    *this=tmp;
    return *this;
}
bool bignum::operator<(const bignum&num) const
{
    if(sign^num.sign)
        return num.sign;
    if(len!=num.len)
        return len<num.len;
    for(int i=len-1;i>=0;i--)
        if(s[i]!=num.s[i])
            return sign?(s[i]<num.s[i]):(!(s[i]<num.s[i]));
    return !sign;
}

bool bignum::operator>(const bignum&num) const
{
    return num<*this;
}

bool bignum::operator<=(const bignum&num) const
{
    return !(*this>num);
}

bool bignum::operator>=(const bignum&num) const
{
    return !(*this<num);
}

bool bignum::operator!=(const bignum&num) const
{
    return *this>num||*this<num;
}

bool bignum::operator==(const bignum&num) const
{
    return !(num!=*this);
}

bignum bignum::operator+(const bignum&num) const
{
    if(sign^num.sign)
    {
        bignum tmp=sign?num:*this;
        tmp.sign=1;
        return sign?*this-tmp:num-tmp;
    }
    bignum result;
    result.len=0;
    int temp=0;
    for(int i=0;temp||i<(max(len,num.len));i++)
    {
        int t=s[i]+num.s[i]+temp;
        result.s[result.len++]=t%10;
        temp=t/10;
    }
    result.sign=sign;
    return result;
}

bignum bignum::operator++()
{
    *this=*this+1;
    return *this;
}

bignum bignum::operator++(int)
{
    bignum old=*this;
    ++(*this);
    return old;
}

bignum bignum::operator+=(const bignum&num)
{
    *this=*this+num;
    return *this;
}

bignum bignum::operator-(const bignum&num) const
{
    bignum b=num,a=*this;
    if(!num.sign&&!sign)
    {
        a.sign=b.sign=1;
        return b-a;
    }
    if(!b.sign)
    {
        b.sign=1;
        return a+b;
    }
    if(!a.sign)
    {
        a.sign=1;
        b=bignum(0)-(a+b);
        return b;
    }
    if(a<b)
    {
        bignum c=(b-a);
        c.sign=false;
        return c;
    }
    bignum result;
    result.len=0;
    for(int i=0,g=0;i<a.len;i++)
    {
        int x=a.s[i]-g;
        if(i<b.len) x-=b.s[i];
        if(x>=0) g=0;
        else g=1,x+=10;
        result.s[result.len++]=x;
    }
    result.clean();
    return result;
}

bignum bignum::operator*(const bignum&num) const
{
    bignum result;
    result.len=len+num.len;
    for(int i=0;i<len;i++)
        for(int j=0;j<num.len;j++)
            result.s[i+j]+=s[i]*num.s[j];
    for(int i=0;i<result.len;i++)
        result.s[i+1]+=result.s[i]/10,result.s[i]%=10;
    result.clean();
    result.sign=!(sign^num.sign);
    return result;
}

bignum bignum::operator*(const int num) const
{
    bignum x=num;
    bignum z=*this;
    return x*z;
}

bignum bignum::operator*=(const bignum&num)
{
    return *this=*this*num;
}

bignum bignum::operator/(const bignum&num) const
{
    bignum ans;
    ans.len=len-num.len+1;
    if(ans.len<0)
    {
        ans.len=1;
        return ans;
    }
    bignum divisor=*this,divid=num;
    divisor.sign=divid.sign=1;
    int k=ans.len-1,j=len-1;
    while(k>=0)
    {
        while(divisor.s[j]==0) j--;
        if(k>j) k=j;
        char z[L];
        memset(z,0,sizeof(z));
        for(int i=j;i>=k;i--)
            z[j-i]=divisor.s[i]+'0';
        bignum dividend=z;
        if(dividend<divid)
        {
            k--;
            continue;
        }
        int key=0;
        while(divid*key<=dividend) key++;
        key--;
        ans.s[k]=key;
        bignum temp=divid*key;
        for(int i=0;i<k;i++)
            temp=temp*10;
        divisor=divisor-temp;
        k--;
    }
    ans.clean();
    ans.sign=!(sign^num.sign);
    return ans;
}

bignum bignum::operator/=(const bignum&num)
{
    *this=*this/num;
    return *this;
}

bignum bignum::operator%(const bignum&num) const
{
    bignum a=*this,b=num;
    a.sign=b.sign=1;
    bignum result,temp=a/b*b;
    result=a-temp;
    result.sign=sign;
    return result;
}

bignum bignum::Pow(const bignum&num) const
{
    bignum result=1;
    for(bignum i=0;i<num;i++)
        result=result*(*this);
    return result;
}

bignum bignum::factorial() const
{
    bignum result=1;
    for(bignum i=1;i<=*this;i++)
        result*=i;
    return result;
}

void bignum::clean()
{
    if(len==0) len++;
    while(len>1&&s[len-1]=='\0')
        len--;
}

bignum bignum::Sqrt() const
{
    if(*this<0) return -1;
    if(*this<=1) return *this;
    bignum l=0,r=*this,mid;
    while(r-l>1)
    {
        mid=(l+r)/2;
        if(mid*mid>*this)
            r=mid;
        else
            l=mid;
    }
    return l;
}

bignum::~bignum()
{
}
bignum num0,num1,res;
int main()
{
    cin >>num0>>num1;
    res = num0*num1;
    cout << res;
    return 0;
}

评测结果