高精度BigInt模板类

精度计算是一种程序设计的算法。由于中央处理器的字长限制，如32位CPU中一个整数最大只能取值4,294,967,295。因此在进行更大范围的数值计算中，往往要采取模拟手段。通常通过分离字符的方法通过数字数组进行输入。通过数组倒序输出。通过模拟竖式计算进行计算。一般而言，主要模拟的是按位运算，可以用不同的进位制达成不同的目的。 ——摘自维基百科

说白了，高精度运算就是为了解决计算机内类型的数据量限制(如c/c++中的long long),从而可以在数据过大时进行处理

当然，高精度中最基础的就是四则运算（没错，就是你小学时候学的那个四则运算），

精髓是把数字一位一位的存储起来（也可以进行压位节省空间，这里暂时不讨论），通过模拟竖式来进行加减乘除（小学基本功）

这里给出一个用BigInt类来实现的高精度模板（c++）

class BigInt{
public:
    int num[100015];
    int size;
public:
    BigInt(){
        size = 0;
        memset(num,0,sizeof(num));
    }
    BigInt(int n){
        memset(num,0,sizeof(num));
        size = 0;
        while(n>0){
            num[size++] = n % 10;
            n /= 10;
        }
    }
    BigInt(string s){
        memset(num,0,sizeof(num));
        size = 0;
        int k = 0;
        while(s[k] == '0')
            k++;
        for(int i = s.length()-1; i >= k; i--){
            num[size++] = s[i] - '0';
        }
    }

    bool operator<(BigInt a){
        if(this->size != a.size){
            return this->size < a.size;
        }
        for (int i = 0; i < size; ++i){
            if(num[i] != a.num[i])
                return num[i]<a.num[i];
        }
        return false;
    }

    BigInt operator +(BigInt a){
        BigInt c;
        int k;
        for(k = 0; k<size && k<a.size; k++){
            c.num[k] = num[k] + a.num[k];
        }
        while(k < size){c.num[k] += num[k];k++;}
        while(k < a.size){c.num[k] += a.num[k];k++;}
        c.size = size>a.size?size:a.size;
        for (int i = 0; i < c.size; ++i){
            if(c.num[i]>=10){
                c.num[i+1] += c.num[i] / 10;
                c.num[i] %= 10;
            }
        }
        if(c.num[c.size] > 0)
            c.size++;
        return c;
    }

    BigInt operator -(BigInt a){
        BigInt x,y;
        BigInt t;
        t.size = size;
        for (int i = 0; i < size; ++i){
            t.num[i] = num[i];
        }
        if(t < a){
            x = a;
            y = t;
        }
        else{
            x = t;
            y = a;
        }
        BigInt r;
        r.size = x.size;
        int k;
        for (k = 0; k < y.size; ++k){
            r.num[k] = x.num[k]-y.num[k];
        }
        while(k < x.size){
            r.num[k] = x.num[k];
            k++;
        }
        for (int i = 0; i < r.size-1; ++i)
        {
            if(r.num[i] < 0){
                r.num[i+1] --;
                r.num[i] += 10;
            }
        }
        while(r.num[r.size-1] == 0)
            r.size--;
        if(t<a)
            r.num[r.size-1] = -r.num[r.size-1];

        return r;
    }

    BigInt operator *(BigInt a){
        BigInt r;
        r.size = size + a.size;
        for (int i = 0; i < size; ++i){
            for (int j = 0; j < a.size; ++j){
                r.num[i+j] += num[i] * a.num[j];
            }
        }
        for (int i = 0; i < r.size-1; ++i){
            r.num[i+1] += r.num[i] / 10;
            r.num[i] %= 10;
        }
        while(r.num[r.size-1] == 0)
            r.size--;
        return r;
    }

    BigInt operator /(int n){
        BigInt r;
        stack<int> s;
        int t = 0;
        for(int i = size-1; i>=0; i--){
            s.push((t*10+num[i])/n);
            t = t*10 + num[i] - n*s.top();
        }
        ans = t;
        while(!s.empty()){
            r.num[r.size++] = s.top();
            s.pop();
        }
        while(r.num[r.size-1] == 0)
            r.size--;
        return r;
    }

    void show(){
        int k = size-1;
        while(num[k] == 0 && k>=0)
            k--;
        if(k<0)
            k = 0;
        for (int i = k; i >=0 ; --i){
            printf("%d", num[i]);
        }
        printf("\n");
    }
};