高精度类模板

高精度除法速度太慢了，还仍需优化

#include<iostream>
#include<vector>
#include<cmath>
#include<string>
#include<iomanip>
#include<algorithm>
using namespace std;

#define MAXN 10000
#define DLEN 4

class BigNum
{
private:
    vector<int> A;
    bool FLAG;
    char cmp(const BigNum &,bool)const;
    void TRIM(){while(!A.empty()&&!A.back())A.pop_back();if(A.empty())FLAG=0;}
public:
    BigNum(){FLAG=0;}
    BigNum(long long);
    void swap(BigNum &T){std::swap(FLAG,T.FLAG);A.swap(T.A);}
    void operator=(const BigNum &T){FLAG=T.FLAG;A=T.A;}
    void operator=(const string &);
    friend istream& operator>>(istream &,BigNum &);
    friend ostream& operator<<(ostream &,BigNum);
    bool   operator>(const BigNum &T){return this->cmp(T,0)>0;}
    bool   operator<(const BigNum &T){return this->cmp(T,0)<0;}
    BigNum operator-()const{BigNum T=*this;T.FLAG=~FLAG;return T;}
    BigNum abs()const{BigNum T=*this;T.FLAG=0;return T;}
    BigNum operator+(const BigNum &) const;
    BigNum operator-(const BigNum &) const;
    BigNum operator*(const BigNum &) const;
    BigNum operator/(const BigNum &)const;
    void operator+=(const BigNum &v){*this=*this+v;}
    void operator-=(const BigNum &v){*this=*this-v;}
    void operator*=(const BigNum &v){*this=*this*v;}
    void operator/=(const BigNum &v){*this=*this/v;}
    BigNum operator+(const long long a) const{return *this+BigNum(a);}
    BigNum operator-(const long long a) const{return *this-BigNum(a);}
    BigNum operator*(const long long a) const{return *this*BigNum(a);}
    BigNum operator/(const long long a) const{return *this/BigNum(a);}
};

char BigNum::cmp(const BigNum &a,bool flag)const
{
    if(flag==0)
    {
        if(FLAG<a.FLAG) return 1;
        if(FLAG>a.FLAG) return -1;
    }
    char F=!FLAG||flag?1:-1;
    if(A.size()>a.A.size()) return F;
    if(A.size()<a.A.size()) return -F;
    for(int i=max(A.size(),a.A.size())-1;i>=0;i--)
    {
        if(A[i]>a.A[i]) return F;
        if(A[i]<a.A[i]) return -F;
    }
    return 0;
}

BigNum::BigNum(long long a)
{
    FLAG=0;
    if(a<0) FLAG=1,a=-a;
    for(;a;a/=MAXN)
        A.push_back(a-(a/MAXN)*MAXN);
}

void BigNum::operator=(const string &s)
{
    int len=0,n=0,m=0;
    if(s[0]=='-') FLAG=1,len=1;
    for(int i=s.size()-1;i>=len;i--)
    {
        if(m==DLEN) A.push_back(n),m=0,n=0;
        n+=(s[i]-'0')*pow(10,m);
        m++;
    }
    if(n>0)A.push_back(n);
}

istream& operator>>(istream &in,BigNum &T)
{
    string s;
    in>>s;
    T=s;
    return in;
}

ostream& operator<<(ostream &out,BigNum T)
{
    if(T.FLAG) out<<'-';
    out<<T.A[T.A.size()-1];
    for(int i=T.A.size()-2;i>=0;i--)
    {
        out.width(DLEN);
        out.fill('0');    
        out<<T.A[i];
    }
    return out;
}

BigNum BigNum::operator+(const BigNum &T) const
{
    if(FLAG==T.FLAG)
    {
        BigNum t(*this);
        int j=max(A.size(),T.A.size());
        for(int i=0,is=0;i<j||is;i++)
        {
            if(i==t.A.size()) t.A.push_back(0);
            t.A[i]+=is+(i<T.A.size()?T.A[i]:0);
            is=t.A[i]>=MAXN;
            if(is)t.A[i]-=MAXN;
        }
        return t;
    }else return *this-(-T);
}

BigNum BigNum::operator-(const BigNum &T) const
{
    if(FLAG==T.FLAG)
    {
        if(~cmp(T,1))
        {
            BigNum t(*this);
            for(int i=0,is=0;i<T.A.size()||is;i++)
            {
                t.A[i]-=is+(i<T.A.size()?T.A[i]:0);
                is=t.A[i]<0;
                if(is) t.A[i]+=MAXN;
            }
            t.TRIM();
            return t;
        }else return -(T-*this);
    }else return *this+(-T);
}

BigNum BigNum::operator*(const BigNum &T) const
{
    BigNum t;
    t.A.resize(A.size()+T.A.size());
    for(int i=0;i<A.size();i++)
        for(int j=0;j<T.A.size();j++)
        {
            t.A[i+j]+=A[i]*T.A[j];
            if(t.A[i+j]>=MAXN)
            {
                t.A[i+j+1]+=t.A[i+j]/MAXN;
                t.A[i+j]-=(t.A[i+j]/MAXN)*MAXN;
            }
        }
    t.TRIM();
    t.FLAG=FLAG*T.FLAG;
    return t;
}

BigNum BigNum::operator/(const BigNum &T)const
{
    switch(this->cmp(T,1))
    {
        case -1:
            return 0;
        case 0:
            return 1;
        case 1:
            BigNum a(*this),b,c,d;
            long long n=this->A.size()-T.A.size();
            for(int i=n;i>=0;i--)
            {
                c=pow(10,i);
                b=T*c;
                while((a-b).FLAG==0)
                {
                    a=a-b;
                    d+=c;
                }
            }
            return d;
    }
    return -1;
}