大整数的四则运算

大整数的四则运算经常用到，有必要专门写一个数据结构当以后用到的时候可以直接使用，原理就是四则运算的笔算，但是写起来细节还是挺多的，虽然并不是很完善，但是一般用来应该足够了

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#define MAXN 1000
using namespace std;

char Ts[MAXN];/*存储tostring的返回值*/
struct bign{
    int len;        /*bign的位数*/
    char s[MAXN];   /*存储bign的各个位,char类型足够了，如果要更省空间一个char类型可以存储2个十进制的数*/
    /** 注：简单起见，并没有设置符号位，定义的全都是unsign的大整数，
     *  编程时遇到有符号的数时容易通过预处理得到无符号数，并通过
     *  结构中提供的重载的比较运算符得到正确的结果
     **/

    bign(){         /*构造函数，声明bign时自动初始化bign*/
        len=1;
        memset(s,0,sizeof(s));
    }

    bign operator = (int num){          /*运算符‘=’重载，当‘=’右面为整数时调用*/
        char a[MAXN];
        sprintf(a,"%d",num);
        *this=a;
        return *this;
    }

    bign operator =(const char *num){   /*运算符‘=’重载，当‘=’右面为字符串时调用*/
        len=strlen(num);
        for(int i=0;i<len;i++)  s[i]=num[len-1-i]-'0';
        return *this;
    }
    bign operator =(const bign &r){
        len=r.len;
        memcpy(s,r.s,sizeof(r.s));
        return *this;
    }

    string tostring ()const{        /*将bign转换为字符串，便于输出*/
        char *p=Ts;
        for(int i=len-1;i>=0;i--)
            *(p++)=s[i]+'0';
        *p='\0';
        return Ts;
    }

    bign operator +(const bign &r){
        bign a;
        int i,c=0,l=len>r.len?len:r.len;
        for(i=0;i<l;i++){
            if(i<r.len)
                c+=r.s[i]+s[i];
            else
                c+=s[i];
            a.s[i]=c%10;
            c/=10;
        }
        (c>0)?(a.s[l]=c,a.len=l+1):(a.len=l);
        return a;
    }

    void clean() {
        while(len > 1 && !s[len-1]) len--;
    }

    bign operator -(const bign &r){
        bign a;
        int i,c=0,l=len>r.len?len:r.len;
        for(i=0;i<l;i++){
            int x=s[i]-c;
            if(i<r.len)
                x-=r.s[i];
            if(x<0){
                c=1;
                x+=10;
            }else
                c=0;
            a.s[i]=x;
        }
        a.len=l;
        a.clean();
        return a;
    }

    bign operator *(const bign &r){
        bign a; a.len=(len+r.len)>MAXN?(len+r.len):MAXN;
        for(int i=0;i<len;i++)
        for(int j=0;j<r.len;j++)
            a.s[i+j]+=s[i]*r.s[j];
        for(int i=0;i<a.len;i++){
            a.s[i+1]+=a.s[i]/10;
            a.s[i]%=10;
        }
        a.clean();
        return a;
    }

    bign operator /(const bign &r){
        bign a,b,c;
        a=*this;
        b=r;
        div(a,b,c,a.len,b.len);
        c.len=a.len-b.len+1;
        c.clean();
        return c;
    }
    void div(bign &a,bign &b,bign &c,const int l1,int l2){
        bign x;
        x.len=l2;
        memcpy(x.s,a.s+l1-l2,sizeof(char)*l2);
        x.clean();
        if(l1<l2||(l1==l2&&x<b))
            return;
        if(x<b){
            div(a,b,c,l1,l2+1);
        }else{
            while(x>=b){
                x=x-b;
                c.s[l1-l2]++;
            }
            memcpy(a.s+l1-l2,x.s,sizeof(char)*l2);
            div(a,b,c,l1,l2+1);
        }
    }

    bool operator < (const bign &r)const{
        if(len!=r.len)  return len<r.len;
        for(int i=len-1;i>=0;i--)
            if(s[i]!=r.s[i])    return s[i]<r.s[i];
        return 0;
    }

    bool operator > (const bign &r)const{
        return r < *this;
    }

    bool operator <= (const bign &r)const{
        return !(r > *this);
    }

    bool operator >=(const bign &r)const{
        return !(r > *this);
    }

    bool operator ==(const bign &r)const{
        return !(*this<r)&&!(*this>r);
    }
};


istream & operator >> (istream &in,bign &r){
    char s[MAXN];
    in>>s;
    r=s;
    return in;
}

ostream & operator <<(ostream &out,const bign &r){
    out<<r.tostring();
    return out;
}

int main() {
  bign a,b;
  cout<<"随便输入两个数字,要求第一个数字大于第二个数字:"<<endl;
  while(cin>>a>>b){

    cout<<"a*b= "<<a*b<<endl;
    cout<<"a/b= "<<a/b<<endl;
    cout<<"a+b= "<<a+b<<endl;
    cout<<"a-b= "<<a-b<<endl;
    cout<<"随便输入两个数字，要求第一个数字大于第二个数字:"<<endl;

  }

  return 0;
}