C + + Template large number

#include <iostream> #include <queue> #include <cstdio> #include <cstring> #include <cstdlib > #include <stack>using namespace std; #define MAXN 120class dividedbyzeroexception {};class biginteger{private    : vector<char> digits;          BOOL sign;        True for positive, false for negitive void trim ();    Remove zeros in tail, but if the value was 0, keep only one:) public:biginteger (int);    construct with a int integer BigInteger (string&);    BigInteger ();    BigInteger (const biginteger&);    BigInteger operator= (const biginteger& OP2);    BigInteger ABS () const;    BigInteger POW (int a);    Binary operators friend BigInteger operator+= (Biginteger&,const biginteger&);    Friend BigInteger operator-= (Biginteger&,const biginteger&);    Friend BigInteger operator*= (Biginteger&,const biginteger&); Friend BigInteger operator/= (biginteger&,const biginteger&) throw (dividedbYzeroexception);    Friend BigInteger operator%= (biginteger&,const biginteger&) throw (dividedbyzeroexception);    Friend BigInteger operator+ (const biginteger&,const biginteger&);    Friend BigInteger operator-(const biginteger&,const biginteger&);    Friend BigInteger operator* (const biginteger&,const biginteger&);    Friend BigInteger operator/(const biginteger&,const biginteger&) throw (dividedbyzeroexception);    Friend BigInteger operator% (const biginteger&,const biginteger&) throw (dividedbyzeroexception);   Uniary operators friend BigInteger operator-(const biginteger&);        Negative friend BigInteger operator++ (biginteger&);    ++v friend BigInteger operator++ (biginteger&,int);        v++ friend BigInteger operator--(biginteger&);    --v friend BigInteger operator--(biginteger&,int);    v--friend bool Operator> (const biginteger&,const biginteger&); friend Bool Operator< (const biginteger&,const biginteger&);    friend bool operator== (const biginteger&,const biginteger&);    friend bool operator!= (const biginteger&,const biginteger&);    friend bool operator>= (const biginteger&,const biginteger&);    friend bool operator<= (const biginteger&,const biginteger&);    Friend ostream& operator<< (Ostream&,const biginteger&);         Print the BigInteger friend istream& operator>> (istream&, biginteger&);    Input the bigintegerpublic:static const BigInteger ZERO;    static const BigInteger One; static const BigInteger ten;};/ /biginteger.cppconst BigInteger Biginteger::zero=biginteger (0); const BigInteger Biginteger::one =biginteger (1); Const BigInteger Biginteger::ten =biginteger (10); Biginteger::biginteger () {sign=true;}    Biginteger::biginteger (int val)//construct with an int integer{if (val >= 0) sign = true; else {sign = false;        Val *= (-1);        } do {digits.push_back ((char) (VAL%10));    Val/= 10; } while (val! = 0);}    Biginteger::biginteger (string& def) {sign=true;  for (String::reverse_iterator iter = Def.rbegin (); Iter < def.rend ();        iter++) {Char ch = (*iter);            if (iter = = Def.rend ()-1) {if (ch = = ' + ') break;                if (ch = = '-') {sign = false;            Break    }} digits.push_back ((char) ((*iter)-' 0 '); } trim ();}    void Biginteger::trim () {Vector<char>::reverse_iterator iter = Digits.rbegin ();        while (!digits.empty () && (*iter) = = 0) {digits.pop_back ();    Iter=digits.rbegin ();        } if (Digits.size () ==0) {sign = true;    Digits.push_back (0);    }}biginteger::biginteger (const biginteger& OP2) {sign = op2.sign; Digits=op2.digits;} BigInteger biginteger::operator= (const BigInteger& OP2) {digits = Op2.digits;    sign = op2.sign; return (*this);}    BigInteger biginteger::abs () const{if (sign) return *this; else return-(*this);}    BigInteger BigInteger::p ow (int a) {BigInteger res (1);    for (int i=0; i<a; i++) res*= (*this); return res;}         Binary Operatorsbiginteger operator+= (biginteger& op1,const biginteger& op2) {if (op1.sign = = op2.sign) {        Only the case of the same symbol is dealt with, the case of the XOR gives-the processing vector<char>::iterator iter1;        Vector<char>::const_iterator Iter2;        Iter1 = Op1.digits.begin ();        Iter2 = Op2.digits.begin ();        char to_add = 0; Carry while (iter1! = Op1.digits.end () && iter2! = Op2.digits.end ()) {(*iter1) = (*iter1            ) + (*ITER2) + To_add;    To_add = ((*iter1) > 9);            Greater than 9 in one bit (*iter1) = (*iter1)% 10;            iter1++;        iter2++; } while (Iter1! = Op1.digits.end ())//{(*iter1) =(*iter1) + To_add;            To_add = ((*iter1) > 9);            (*iter1)%= 10;        iter1++;            } while (Iter2! = Op2.digits.end ()) {char val = (*iter2) + To_add;            To_add = (val > 9);            Val%= 10;            Op1.digits.push_back (Val);        iter2++;        } if (To_add! = 0) Op1.digits.push_back (to_add);    return OP1;        } else {if (op1.sign) return OP1-= (-OP2);    else return op1= OP2-(-OP1); }}biginteger operator-= (biginteger& op1,const biginteger& op2) {if (op1.sign = = op2.sign) {//handle only the same The case of the symbol, the case of the XOR gives + processing if (op1.sign) {if (OP1 < OP2)//2-3 return op1=-(OP2-OP1)        ;            } else {if (-op1 >-op2)//( -3)-( -2) =-(3-2) return op1=-((-OP1)-(-OP2)); else//( -2)-( -3) = 3-2 return op1= (-OP2)-(-OP1);        } Vector<char>::iterator Iter1;        Vector<char>::const_iterator Iter2;        Iter1 = Op1.digits.begin ();        Iter2 = Op2.digits.begin ();  char to_substract = 0; Borrow while (iter1! = Op1.digits.end () && iter2! = Op2.digits.end ()) {(*iter1) = (*iter1            )-(*iter2)-to_substract;            to_substract = 0;                if ((*iter1) < 0) {to_substract=1;            (*iter1) + = 10;            } iter1++;        iter2++;            } while (Iter1! = Op1.digits.end ()) {(*iter1) = (*iter1)-to_substract;            to_substract = 0;                if ((*iter1) < 0) {to_substract=1;            (*iter1) + = 10;            } else break;        iter1++;        } Op1.trim ();    return OP1;        } else {if (Op1 > Biginteger::zero) return OP1 + = (-OP2); Else return OP1 =-(OP2 + (-OP1));    }}biginteger operator*= (biginteger& op1,const biginteger& op2) {BigInteger result (0);    if (OP1 = = Biginteger::zero | | op2==biginteger::zero) result = Biginteger::zero;        else {Vector<char>::const_iterator iter2 = Op2.digits.begin (); while (iter2! = Op2.digits.end ()) {if (*iter2! = 0) {deque<char> temp (                Op1.digits.begin (), Op1.digits.end ());                char to_add = 0;                Deque<char>::iterator iter1 = Temp.begin ();                    while (Iter1! = Temp.end ()) {(*iter1) *= (*ITER2);                    (*iter1) + = To_add;                    To_add = (*iter1)/10;                    (*iter1)%= 10;                iter1++;                } if (To_add! = 0) Temp.push_back (to_add);               int num_of_zeros = Iter2-op2.digits.begin (); while (num_of_zeros--) temp.push_front (0);                BigInteger Temp2;                Temp2.digits.insert (Temp2.digits.end (), Temp.begin (), Temp.end ());                Temp2.trim ();            result = result + Temp2;        } iter2++; } result.sign = ((op1.sign && op2.sign) | |    (!op1.sign &&!op2.sign));    } OP1 = result; return OP1;} BigInteger operator/= (biginteger& op1, const biginteger& OP2) throw (dividedbyzeroexception) {if (OP2 = = Bigin    Teger::zero) throw dividedbyzeroexception ();    BigInteger T1 = op1.abs (), t2 = Op2.abs ();        if (T1 < t2) {OP1 = Biginteger::zero;    return OP1;    }//Now T1 > T2 > 0//Just give the result of t1/t2 to result can be deque<char> temp;    Vector<char>::reverse_iterator iter = T1.digits.rbegin ();    BigInteger temp2 (0); while (iter! = T1.digits.rend ()) {Temp2 = Temp2 * Biginteger::ten + BigInteger ((int)(*iter));        char s = 0;            while (Temp2 >= t2) {temp2 = Temp2-t2;        s = s + 1;        } temp.push_front (s);    iter++;    } op1.digits.clear ();    Op1.digits.insert (Op1.digits.end (), Temp.begin (), Temp.end ());    Op1.trim (); Op1.sign = ((op1.sign && op2.sign) | |    (!op1.sign &&!op2.sign)); return OP1;}  BigInteger operator%= (biginteger& op1,const biginteger& op2) throw (dividedbyzeroexception) {return OP1-= ((OP1 /OP2) *OP2);}    BigInteger operator+ (const biginteger& op1,const biginteger& op2) {BigInteger temp (OP1);    temp + = OP2; return temp;}    BigInteger operator-(const biginteger& op1,const biginteger& op2) {BigInteger temp (OP1);    Temp-= OP2; return temp;}    BigInteger operator* (const biginteger& op1,const biginteger& op2) {BigInteger temp (OP1);    Temp *= OP2; return temp;} BigInteger operator/(const biginteger& op1,const biginteger& OP2) throW (dividedbyzeroexception) {BigInteger temp (OP1);    Temp/= OP2; return temp;} BigInteger operator% (const biginteger& op1,const biginteger& op2) throw (dividedbyzeroexception) {BigInteger te    MP (OP1);    Temp%= OP2; return temp;}    Uniary Operatorsbiginteger operator-(const biginteger& op)//negative{BigInteger temp = BigInteger (OP);    Temp.sign =!temp.sign; return temp;}    BigInteger operator++ (biginteger& op)//++v{op + = Biginteger::one; return op;    BigInteger operator++ (biginteger& op,int x)//v++{BigInteger Temp (OP);    ++op; return temp;}    BigInteger operator--(biginteger& op)//--v{op-= Biginteger::one; return op;    BigInteger operator--(biginteger& op,int x)//v--{BigInteger Temp (OP);    --op; return temp;} BOOL operator< (const biginteger& op1,const biginteger& OP2) {if (op1.sign! = op2.sign) return!OP1.S    Ign      else {if (op1.digits.size ()! = Op2.digits.size ())      Return (op1.sign && op1.digits.size () <op2.digits.size ()) | |        (!op1.sign && op1.digits.size () >op2.digits.size ());        Vector<char>::const_reverse_iterator Iter1,iter2;        Iter1 = Op1.digits.rbegin ();        Iter2 = Op2.digits.rbegin ();            while (Iter1! = Op1.digits.rend ()) {if (op1.sign && *iter1 < *iter2) return true;            if (op1.sign && *iter1 > *iter2) return false;            if (!op1.sign && *iter1 > *iter2) return true;            if (!op1.sign && *iter1 < *iter2) return false;            iter1++;        iter2++;    } return false; }}bool operator== (const biginteger& op1,const biginteger& OP2) {if (op1.sign! = Op2.sign | | op1.digits.size ()    ! = Op2.digits.size ()) return false;    Vector<char>::const_iterator Iter1,iter2;    Iter1 = Op1.digits.begin ();    Iter2 = Op2.digits.begin (); while (iter1!= Op1.digits.end ()) {if (*iter1! = *iter2) return false;        iter1++;    iter2++; } return true; BOOL Operator!= (const biginteger& op1,const biginteger& OP2) {return! OP1==OP2);} BOOL Operator>= (const biginteger& op1,const biginteger& OP2) {return (OP1&GT;OP2) | | (OP1==OP2);} BOOL Operator<= (const biginteger& op1,const biginteger& OP2) {return (OP1&LT;OP2) | | (OP1==OP2);} BOOL Operator> (const biginteger& op1,const biginteger& OP2) {return! OP1&LT;=OP2);}         ostream& operator<< (ostream& stream,const biginteger& val)//print the biginteger{if (!val.sign)    Stream << "-"; for (Vector<char>::const_reverse_iterator iter = Val.digits.rbegin (); ITER! = Val.digits.rend (); iter++) St    Ream << (char) ((*iter) + ' 0 '); return stream;}    istream& operator>> (istream& stream, biginteger& val) {//input the BigInteger string str; Stream >>Str    Val=biginteger (str); return stream;}    int main () {int t;    BigInteger p, q, ans;    cin>>t;        while (t--) {cin>>p>>q;        Ans = (p-1) * (p-2)/2;        Ans%= Q;    cout<<ans<<endl; } return 0;}

C + + template large number