高精度模板

1.  C++大数类模板

　　版本1：Copy from JayYe

/*
    高精度模版
*/

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;

const int numlen = 2005; // 需要的位数
const int numbit = 4;   // 数组一位表示的整数
const int addbit = 10000;//进位数
const int maxn = numlen/numbit + 10;   // 数组要开的位数

int max(int a, int b) { return a>b?a:b; }
struct bign {
    int len, s[numlen];
    bign() {
        memset(s, 0, sizeof(s));
        len = 1;
    }
    bign(int num) { *this = num; }
    bign(const char *num) { *this = num; }
    bign operator = (const int num) {
        char s[numlen];
        sprintf(s, "%d", num);
        *this = s;
        return *this;
    }
    bign operator = (const char *num) {
        int clen = strlen(num);
        while(clen > 1 && num[0] == '0') num++, clen--;
        len = 0;
        for(int i = clen-1;i >= 0;i -= numbit) {
            int top = min(numbit, i+1), mul = 1;
            s[len] = 0;
            for(int j = 0;j < top; j++) {
                s[len] += (num[i-j]-'0')*mul;
                mul *= 10;
            }
            len++;
        }
        deal();
        return *this;
    }

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

    bign operator + (const bign &a) const {
        bign ret;
        ret.len = 0;
        int top = max(len, a.len) , add = 0;
        for(int i = 0;add || i < top; i++) {
            int now = add;
            if(i < len) now += s[i];
            if(i < a.len)   now += a.s[i];
            ret.s[ret.len++] = now%addbit;
            add = now/addbit;
        }
        return ret;
    }
    bign operator - (const bign &a) const {
        bign ret;
        ret.len = 0;
        int cal = 0;
        for(int i = 0;i < len; i++) {
            int now = s[i] - cal;
            if(i < a.len)   now -= a.s[i];
            if(now >= 0)    cal = 0;
            else {
                cal = 1; now += addbit;
            }
            ret.s[ret.len++] = now;
        }
        ret.deal();
        return ret;
    }
    bign operator * (const bign &a) const {
        bign ret;
        ret.len = len + a.len;
        for(int i = 0;i < len; i++) {
            int pre = 0;
            for(int j = 0;j < a.len; j++) {
                int now = s[i]*a.s[j] + pre;
                pre = 0;
                ret.s[i+j] += now;
                if(ret.s[i+j] >= addbit) {
                    pre = ret.s[i+j]/addbit;
                    ret.s[i+j] -= pre*addbit;
                }
            }
            if(pre) ret.s[i+a.len] = pre;
        }
        ret.deal();
        return ret;
    }

    //乘以小数，直接乘快点  ***********注意计算过程可能会爆int
    bign operator * (const int num) {
        bign ret;
        ret.len = 0;
        int bb = 0;
        for(int i = 0;i < len; i++) {
            int now = bb + s[i]*num;
            ret.s[ret.len++] = now%addbit;
            bb = now/addbit;
        }
        while(bb) {
            ret.s[ret.len++] = bb % addbit;
            bb /= addbit;
        }
        ret.deal();
        return ret;
    }
    // 除以一个小整数     ***********注意计算过程可能会爆int
    bign operator / (const int a) const {
        bign ret;
        ret.len = len;
        int pre = 0;
        for(int i = len-1;i >= 0; i--) {
            ret.s[i] = (s[i] + pre*addbit)/a;
            pre = s[i] + pre*addbit - a*ret.s[i];
        }
        ret.deal();
        return ret;
    }


    bign operator % (const int a) const {
        bign b = *this / a;
        return *this - b*a;
    }

    bign operator += (const bign &a) { *this = *this + a; return *this; }
    bign operator -= (const bign &a) { *this = *this - a; return *this; }
    bign operator *= (const bign &a) { *this = *this * a; return *this; }
    bign operator /= (const int a) { *this = *this / a; return *this; }
    bign operator %= (const int a) { *this = *this % a; return *this; }

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

    void print() {
        printf("%d", s[len-1]);
        for(int i = len-2;i >= 0; i--) {
            printf("%04d", s[i]);
        }
        puts("");
    }

    string str() const {
        string ret = "";
        for(int i = 0;i < len; i++) ret = char(s[i] + '0') + ret;
        return ret;
    }
};
istream& operator >> (istream &in, bign &x) {
    string s;
    in >> s;
    x = s.c_str();
    return in;
}
ostream& operator << (ostream &out, const bign &x) {
    printf("%d", x.s[x.len-1]);
    for(int i = x.len-2;i >= 0; i--)    printf("%04d", x.s[i]);
    return out;
}

　　

　　版本2：Copy from Kuangbin

/* 
 * 完全大数模板 By Kuangbin
 * 输出cin>>a 
 * 输出a.print(); 
 * 注意：这个输入不能自动去掉前导0的，
 *		先读入到char数组，去掉前导0，再用构造函数。
 */ 
#define MAXN 9999 
#define MAXSIZE 1010 
#define DLEN 4 

class BigNum 
{ 
private: 
    int a[500];  //可以控制大数的位数 
    int len; 
public: 
    BigNum(){len=1;memset(a,0,sizeof(a));}  //构造函数 
    BigNum(const int);     //将一个int类型的变量转化成大数 
    BigNum(const char*);   //将一个字符串类型的变量转化为大数 
    BigNum(const BigNum &); //拷贝构造函数 
    BigNum &operator=(const BigNum &); //重载赋值运算符，大数之间进行赋值运算 
    friend istream& operator>>(istream&,BigNum&); //重载输入运算符 
    friend ostream& operator<<(ostream&,BigNum&); //重载输出运算符 
 
    BigNum operator+(const BigNum &)const;  //重载加法运算符，两个大数之间的相加运算 
    BigNum operator-(const BigNum &)const;  //重载减法运算符，两个大数之间的相减运算 
    BigNum operator*(const BigNum &)const;  //重载乘法运算符，两个大数之间的相乘运算 
    BigNum operator/(const int &)const;     //重载除法运算符，大数对一个整数进行相除
运算 
 
    BigNum operator^(const int &)const;     //大数的n次方运算 
    int operator%(const int &)const;        //大数对一个int类型的变量进行取模运算
    bool operator>(const BigNum &T)const;   //大数和另一个大数的大小比较 
    bool operator>(const int &t)const;      //大数和一个int类型的变量的大小比较
 
    void print();        //输出大数 
}; 
BigNum::BigNum(const int b)   //将一个int类型的变量转化为大数 
{ 
    int c,d=b; 
    len=0; 
    memset(a,0,sizeof(a)); 
    while(d>MAXN) 
    { 
        c=d-(d/(MAXN+1))*(MAXN+1); 
        d=d/(MAXN+1); 
        a[len++]=c; 
    } 
    a[len++]=d; 
} 
BigNum::BigNum(const char *s)  //将一个字符串类型的变量转化为大数 
{ 
    int t,k,index,L,i; 
    memset(a,0,sizeof(a)); 
    L=strlen(s); 
    len=L/DLEN; 
    if(L%DLEN)len++; 
    index=0; 
    for(i=L-1;i>=0;i-=DLEN) 
    { 
        t=0; 
        k=i-DLEN+1; 
        if(k<0)k=0; 
        for(int j=k;j<=i;j++) 
            t=t*10+s[j]-'0'; 
        a[index++]=t; 
    } 
} 
BigNum::BigNum(const BigNum &T):len(T.len)  //拷贝构造函数 
{ 
    int i; 
    memset(a,0,sizeof(a)); 
    for(i=0;i<len;i++) 
        a[i]=T.a[i]; 
} 
BigNum & BigNum::operator=(const BigNum &n)  //重载赋值运算符，大数之间赋值运算
{ 
    int i; 
    len=n.len; 
    memset(a,0,sizeof(a)); 
    for(i=0;i<len;i++) 
        a[i]=n.a[i]; 
    return *this; 
} 
istream& operator>>(istream &in,BigNum &b) 
{ 
    char ch[MAXSIZE*4]; 
    int i=-1; 
    in>>ch; 
    int L=strlen(ch); 
    int count=0,sum=0; 
    for(i=L-1;i>=0;) 
    { 
        sum=0; 
        int t=1; 
        for(int j=0;j<4&&i>=0;j++,i--,t*=10) 
        { 
            sum+=(ch[i]-'0')*t; 
        } 
        b.a[count]=sum; 
        count++; 
    } 
    b.len=count++; 
    return in; 
} 
ostream& operator<<(ostream& out,BigNum& b)  //重载输出运算符 
{ 
    int i; 
    cout<<b.a[b.len-1]; 
    for(i=b.len-2;i>=0;i--) 
    { 
        printf("%04d",b.a[i]); 
    } 
    return out; 
} 
BigNum BigNum::operator+(const BigNum &T)const   //两个大数之间的相加运
{ 
    BigNum t(*this); 
    int i,big; 
    big=T.len>len?T.len:len; 
    for(i=0;i<big;i++) 
    { 
        t.a[i]+=T.a[i]; 
        if(t.a[i]>MAXN) 
        { 
            t.a[i+1]++; 
            t.a[i]-=MAXN+1; 
        } 
    } 
    if(t.a[big]!=0) 
       t.len=big+1; 
    else t.len=big; 
    return t; 
} 
BigNum BigNum::operator-(const BigNum &T)const  //两个大数之间的相减运算 
{ 
    int i,j,big; 
    bool flag; 
    BigNum t1,t2; 
    if(*this>T) 
    { 
        t1=*this; 
        t2=T; 
        flag=0; 
    } 
    else 
    { 
        t1=T; 
        t2=*this; 
        flag=1; 
    } 
    big=t1.len; 
    for(i=0;i<big;i++) 
    { 
        if(t1.a[i]<t2.a[i]) 
        { 
            j=i+1; 
            while(t1.a[j]==0) 
                j++; 
            t1.a[j--]--; 
            while(j>i) 
                t1.a[j--]+=MAXN; 
            t1.a[i]+=MAXN+1-t2.a[i]; 
        } 
        else t1.a[i]-=t2.a[i]; 
    } 
    t1.len=big; 
    while(t1.a[len-1]==0 && t1.len>1) 
    { 
        t1.len--; 
        big--; 
    } 
    if(flag) 
        t1.a[big-1]=0-t1.a[big-1]; 
    return t1; 
} 
BigNum BigNum::operator*(const BigNum &T)const  //两个大数之间的相乘 
{ 
    BigNum ret; 
    int i,j,up; 
    int temp,temp1; 
    for(i=0;i<len;i++) 
    { 
        up=0; 
        for(j=0;j<T.len;j++) 
        { 
            temp=a[i]*T.a[j]+ret.a[i+j]+up; 
            if(temp>MAXN) 
            { 
                temp1=temp-temp/(MAXN+1)*(MAXN+1); 
                up=temp/(MAXN+1); 
                ret.a[i+j]=temp1; 
            } 
            else 
            { 
                up=0; 
                ret.a[i+j]=temp; 
            } 
        } 
        if(up!=0) 
           ret.a[i+j]=up; 
    } 
    ret.len=i+j; 
    while(ret.a[ret.len-1]==0 && ret.len>1)ret.len--; 
    return ret; 
} 
BigNum BigNum::operator/(const int &b)const  //大数对一个整数进行相除运算
{ 
    BigNum ret; 
    int i,down=0; 
    for(i=len-1;i>=0;i--) 
    { 
        ret.a[i]=(a[i]+down*(MAXN+1))/b; 
        down=a[i]+down*(MAXN+1)-ret.a[i]*b; 
    } 
    ret.len=len; 
    while(ret.a[ret.len-1]==0 && ret.len>1) 
        ret.len--; 
    return ret; 
} 
int BigNum::operator%(const int &b)const   //大数对一个 int类型的变量进行取模 
{ 
    int i,d=0; 
    for(i=len-1;i>=0;i--) 
        d=((d*(MAXN+1))%b+a[i])%b; 
    return d; 
} 
BigNum BigNum::operator^(const int &n)const  //大数的n次方运算 
{ 
    BigNum t,ret(1); 
    int i; 
    if(n<0)exit(-1); 
    if(n==0)return 1; 
    if(n==1)return *this; 
    int m=n; 
    while(m>1) 
    { 
        t=*this; 
        for(i=1;(i<<1)<=m;i<<=1) 
           t=t*t; 
        m-=i; 
        ret=ret*t; 
        if(m==1)ret=ret*(*this); 
    } 
    return ret; 
} 
bool BigNum::operator>(const BigNum &T)const    //大数和另一个大数的大小比较 
{ 
    int ln; 
    if(len>T.len)return true; 
    else if(len==T.len) 
    { 
        ln=len-1; 
        while(a[ln]==T.a[ln]&&ln>=0) 
          ln--; 
        if(ln>=0 && a[ln]>T.a[ln]) 
           return true; 
        else 
           return false; 
    } 
    else 
       return false; 
} 

bool BigNum::operator>(const int &t)const  //大数和一个int类型的变量的大小比较
{ 
    BigNum b(t); 
    return *this>b; 
} 
void BigNum::print()   //输出大数 
{ 
    int i; 
    printf("%d",a[len-1]); 
    for(i=len-2;i>=0;i--) 
      printf("%04d",a[i]); 
    printf("\n"); 
}