C++实现大正整数及其相关运算(长期更新)

/**
    只考虑正数[1, +∞);
    “-”运算只允许大数减小数;
    小端存储；
*/
typedef struct BigInteger0 {
    vector<int> v;
    BigInteger0(int len) {
        v.resize(len);
    }
    BigInteger0(const vector<int>& nv) {
        v.assign(nv.begin(), nv.end());
    }
    BigInteger0(const char str[]) {
        int len = strlen(str);
        v.resize(len);
        for(int i = 0; i < len; ++i)
            v[len - 1 - i] = str[i] - ‘0‘;
    }
    BigInteger0 operator + (const BigInteger0& obj) const {
        BigInteger0 res(v);
        int len = max(v.size(), obj.v.size());
        res.v.resize(len + 1);
        for(int i = 0; i < len; ++i) {
            if(i < obj.v.size())res.v[i] += obj.v[i];
            if(res.v[i] >= 10) {
                res.v[i + 1] += res.v[i] / 10;
                res.v[i] %= 10;
            }
        }
        if(res.v[res.v.size() - 1] == 0)res.v.resize(res.v.size() - 1);
        return res;
    }

    /*默认v > obj，即v.size() > obj.v.size()*/
    BigInteger0 operator - (const BigInteger0& obj) const {
        BigInteger0 res(v);
        for(int i = 0; i < v.size(); ++i) {
            if(i < obj.v.size())res.v[i] -= obj.v[i];
            if(res.v[i] < 0) {
                res.v[i + 1]--;
                res.v[i] += 10;
            }
        }
        int len = res.v.size();
        for(; res.v[len - 1] == 0; --len);
        res.v.resize(len);
        return res;
    }

    BigInteger0 operator * (const BigInteger0& obj) const {
        BigInteger0 res(v.size() + obj.v.size());
        for(int i = 0, len1 = v.size(); i < len1; ++i) {
            for(int j = 0, len2 = obj.v.size(); j < len2; ++j) {
                res.v[i + j] += v[i] * obj.v[j];
                if(res.v[i + j] >= 10) {
                    res.v[i + j + 1] += res.v[i + j] / 10;
                    res.v[i + j] %= 10;
                }
            }
        }
        int len = res.v.size();
        for(; res.v[len - 1] == 0; --len);
        res.v.resize(len);
        return res;
    }

    BigInteger0 operator / (BigInteger0& obj) const {
        if(*this < obj)return BigInteger0("0");
        else if(*this == obj)return BigInteger0("1");
        else {
            BigInteger0 res("0"), ten("10"), tmp(v);
            while(tmp > obj) {
                int lendif = tmp.v.size() - obj.v.size();
                BigInteger0 b1 = ten ^ lendif;
                BigInteger0 b2 = b1 * obj;
                if(tmp < b2) {
                    b1 = ten ^ (lendif - 1);
                    b2 = b1 * obj;
                }
                while(tmp >= b2) {
                    tmp = tmp - b2;
                    res = res + b1;
                }
            }
            return res;
        }
    }

    /**power*/
    BigInteger0 operator ^ (int n) const {
        BigInteger0 res("1"), tmp(v);
        for(; n > 0; n >>= 1) {
            if(n & 1)res = res * tmp;
            tmp = tmp * tmp;
        }
        return res;
    }

    BigInteger0 sqrt() {
        int len = (v.size() + 1) / 2;
        BigInteger0 res(len), ten("10");
        for(int i = len - 1; i >= 0; --i) {
            int low = -1, high = 10, mid, bit;
            while(low < high - 1) {
                mid = (low + high) >> 1;
                BigInteger0 b = res + (BigInteger0(vector<int>(1, mid)) * (ten ^ i));
                if(b * b <= *this) {
                    low = mid;
                    bit = mid;
                }
                else high = mid;
            }
            res.v[i] = bit;
        }
        for(; res.v[len - 1] == 0; --len);
        res.v.resize(len);
        return res;
    }

    bool operator < (const BigInteger0& obj) const {
        if(v.size() < obj.v.size())return true;
        else if(v.size() > obj.v.size())return false;
        else {
            int i = v.size() - 1;
            for(; i >= 0 && v[i] == obj.v[i]; --i);
            if(i < 0)return false;
            else return v[i] < obj.v[i];
        }
    }

    bool operator > (const BigInteger0& obj) const {
        return obj < *this;
    }

    bool operator == (const BigInteger0& obj) const {
        if(v.size() != obj.v.size())return false;
        else {
            for(int i = 0; i < v.size(); ++i) {
                if(v[i] != obj.v[i])return false;
            }
            return true;
        }
    }

    bool operator >= (const BigInteger0& obj) const {
        return *this > obj || *this == obj;
    }

    bool operator <= (const BigInteger0& obj) const {
        return *this < obj || *this == obj;
    }

    string value() {
        string res;
        for(int i = v.size() - 1; i >= 0; --i)res.push_back(v[i] + ‘0‘);
        if(v.size() == 0)res.push_back(‘0‘);
        return res;
    }
} BigInteger;