高精度模板

此模板大部分原创，不能保证绝对的正确性，还请多多指教

#include <vector>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
typedef long long LL;

struct BigNum : vector<int> {
    int flag;               //标记符号 flag为1则为正，为-1则为负 注意flag是int类型，为此我调了很长时间TAT
    BigNum() {              //为什么我不用0和1来区别呢？
        flag = 1;           //因为 运算要考虑符号的时候，直接 数值×flag 就好了
    }

    inline BigNum ABS() const {     //绝对值  实际上就是去符号
        BigNum res(*this);
        res.flag = 1;
        return res;
    }

    //---------------读入部分---------------

    inline BigNum operator = (char *st) {   //字符串读入
        if(st[0] == '-') {
            flag = -1;
            int len = strlen(st)-1;
            for(int i = len; i > 0; i--) {
                push_back((st)[i] - '0');
            }
            return *this;
        }
        int len = strlen(st);
        for(int i = len-1; i >= 0; i--) {
            push_back((st)[i] - '0');
        }
        return *this;
    }
    inline BigNum operator = (int b) {      //int读入
        if(b < 0) flag = -1;
        while(b) {
            push_back(b % 10);
            b = b / 10;
        }
        return *this;
    }
    inline BigNum operator = (LL b) {       //long long读入 
        if(b < 0) flag = -1;
        while(b) {
            push_back(b % 10);
            b = b / 10;
        }
        return *this;
    }

    //---------------运算部分---------------

    inline BigNum check() {                     //这是一个非常关键的函数， 可称为进位函数
        if(size() == 1 && !back()) {            //去除前导0  数字串为空时添一个0
            flag = 1; return *this ;
        }
        while(!empty() && !back()) pop_back();
        if(empty()){
            push_back(0);
            flag = 1;
            return *this;
        }

        for(int i = 1; i < size(); i++) {       //进位
            (*this)[i] += (*this)[i-1]/10;
            (*this)[i-1] %= 10;
        }
        for(int i = 0; i < size()-1; i++) {     //变负为正
            if((*this)[i] < 0) {
                (*this)[i+1]--;
                (*this)[i] += 10;
            }
        }
        while(back() >= 10) {                   //最高位进位
            push_back( back()/10 );
            (*this)[size()-2] %= 10;
        }
        if(back() < 0) {                        //最高位变负为正
            flag = -1;
            back() = -back();
        }
        return *this;
    }

    inline bool operator != (const BigNum b) const {    //      !=
        if(flag != b.flag) return 0;
        if(size() != b.size()) return 1;
        for(int i = size()-1; i >= 0; i--)
            if((*this)[i] != b[i]) return 1;
        return 0;
    }
    inline bool operator == (const BigNum b) const {    //      ==
        return !(*this != b);
    }
    inline bool operator < (const BigNum b) const {     //      <
        if(flag < b.flag) return 1;
        if(size() != b.size()) {
            if(flag == 1) return size() < b.size();
            else return b.size() < size();
        }
        for(int i = size()-1; i >= 0; i--)
            if((*this)[i] != b[i]) {
                if(flag == 1) return (*this)[i] < b[i];
                else return b[i] > (*this)[i];
            }
        return 0;
    }
    inline bool operator > (const BigNum b) const {     //      >
        return b < *this;
    }
    inline bool operator <= (const BigNum b) const {    //      <=
        return !(b < *this);
    }
    inline bool operator >= (const BigNum b) const {    //      >=
        return !(*this < b);
    }


    inline BigNum operator + (const BigNum b) const {   //      +   加法
        BigNum res;
        int len = min(size(), b.size()), i;
        for(i = 0; i < len; i++) res.push_back( (*this)[i] * flag + b[i] * b.flag );
        while(i < size())   res.push_back( (*this)[i++] * flag );
        while(i < b.size()) res.push_back( b[i++] * b.flag );
        return res.check();
    }
    inline BigNum operator += (const BigNum b)  {       //      +=
        return *this = *this + b;
    }

    inline BigNum operator - (const BigNum b) const {   //      -   减法
        BigNum res;
        int len = min(size(), b.size()), i;
        for(i = 0; i < len; i++) res.push_back( (*this)[i] * flag - b[i] * b.flag );
        while(i < size()) res.push_back( (*this)[i++] * flag );
        while(i < b.size()) res.push_back( b[i++] * b.flag );
        return res.check();
    }
    inline BigNum operator -= (const BigNum b)  {       //      -=
        return *this = *this - b;
    }

    inline BigNum operator * (const BigNum b) const {   //      *   乘法
        BigNum res;
        res.assign(size() + b.size(), 0);
        for(int i = 0; i < size(); i++)
            for(int j = 0; j < b.size(); j++) {
                res[i+j] += (*this)[i] * b[j];
            }
        res.flag = flag * b.flag;
        return res.check();
    }
    inline BigNum operator *= (const BigNum b)  {       //      *=
        return *this = *this * b;
    }

    inline BigNum operator / (const BigNum b) const {   //      /   除法（整除，向下取整，高精度除以高精度）
        BigNum tmp = ABS(), tb = b.ABS(), res;
        for(int i = size() - tb.size(); tmp >= tb; i--) {
            BigNum d;
            d.assign(i+1, 0);
            d.back() = 1;
            BigNum c = tb * d;
            while(tmp >= c) {
                tmp = tmp - c;
                res = res + d;
            }
        }
        res.flag = flag * b.flag;
        return res.check();
    }
    inline BigNum operator /= (const BigNum b)  {       //      /=
        return *this = *this / b;
    }

    inline BigNum operator % (const BigNum b) const {   //      %   模运算
        BigNum res = *this;
        res -= (*this / b) * b;
        return res.check();
    }
    inline BigNum operator %= (const BigNum b)  {       //      %=
        return *this = *this % b;
    }

    inline BigNum operator / (const int b) const {      //      /   除法（整除，向下取整，高精度除以低精度）
        BigNum res;
        res.assign(size(), 0);
        int d = 0;
        for(int i = size()-1; i >= 0; i--) {
            d = d*10 + (*this)[i];
            res[i] = d / b;
            d = d % b;
        }
        res.flag = flag * (b < 0 ? -1 : 1);
        return res.check();
    }

    //---------------输出部分---------------

    inline void print() {                       //输出（带换行）
        if(flag == -1) printf("-");
        for (int i = size() - 1; i >= 0; i--)
            printf("%d", (*this)[i]);
        puts("");
    }
};

BigNum Qpow(BigNum x, BigNum k) {               //快速幂（然而我写的这个并不很快，甚至很慢）
    BigNum res;
    if(x.size() == 1 && !x.back()) return res.check();
    res.push_back(1);   
    if(k.size() == 1 && !k.back()) return res.check();  
    while( !(k.size() == 1 && !k.back()) ) {
        if(k[0] & 1) res *= x;
        x = x * x;
        k = k / 2;
    }
    return res.check();
}

int main() {
    char st[2][100];
    scanf("%s %s", st[0], st[1]);
    BigNum a, b;
    a = st[0];
    b = st[1];

    BigNum c1 = a + b;
    BigNum c2 = a; c2 += b;
    BigNum d1 = a - b;
    BigNum d2 = a; d2 -= b;
    BigNum e1 = a * b;
    BigNum e2 = a; e2 *= b;
    BigNum f1 = a / b;
    BigNum f2 = a; f2 /= b;
    BigNum g1 = a % b;
    BigNum g2 = a; g2 %= b;
    BigNum  h = Qpow(a, b);

    printf("a != b  %d\n", a != b);
    printf("a == b  %d\n", a == b);
    printf(" a < b  %d\n", a < b);
    printf(" a > b  %d\n", a > b);
    printf("a <= b  %d\n", a <= b);
    printf("a >= b  %d\n", a >= b);
    puts("");

    printf(" a + b  "), c1.print();
    printf("   += b "), c2.print();
    printf(" a - b  "), d1.print();
    printf("   -= b "), d2.print();
    printf(" a * b  "), e1.print();
    printf("   *= b "), e2.print();
    printf(" a / b  "), f1.print();
    printf("   /= b "), f2.print();
    printf("a mod b "), g1.print();
    printf("a mod=b "), g2.print();
    printf(" a ^b   "), h.print(); // b >= 0

    puts("");

    /*
    int t1; LL t2;
    scanf("%d%lld", &t1, &t2);
    BigNum x, y;
    x = t1, y = t2;
    BigNum z = x + y;

    z.print();
    */
    return 0;
}