大整数模板

　　稍微测试了一下感觉还行，可能有BUG，如果发现了还望告诉我。代码是C++11写的，要有能支持constexpr这些关键字的编译器才可以编译出来。

　　update: 2016.8.5 15:51 加了个可以转出字符串的功能

#pragma once
#ifndef BigIntNums_H
#define BigIntNums_H

#include <vector>
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <sstream>
#include <string>
#include <cstring>

using std::reverse;
using std::right;
using std::left;
using std::setw;
using std::setfill;
using std::stringstream;
using std::string;

using std::ostream;
using std::istream;

class BigIntNums;

bool operator==(const BigIntNums &, const BigIntNums &);
bool operator!=(const BigIntNums &, const BigIntNums &);
bool operator<(const BigIntNums &, const BigIntNums &);
bool operator>(const BigIntNums &, const BigIntNums &);
bool operator<=(const BigIntNums &, const BigIntNums &);
bool operator>=(const BigIntNums &, const BigIntNums &);
ostream &operator<<(ostream &, const BigIntNums &);
istream &operator>>(istream &, BigIntNums &);
BigIntNums operator+(const BigIntNums &, const BigIntNums &);
BigIntNums operator*(const BigIntNums &, const BigIntNums &);
BigIntNums operator-(const BigIntNums &, const BigIntNums &);
BigIntNums operator/(const BigIntNums &, const BigIntNums &);
BigIntNums operator%(const BigIntNums &, const BigIntNums &);
BigIntNums operator-(const BigIntNums &);
BigIntNums abs(const BigIntNums &);

class BigIntNums
{
    friend ostream &operator<<(ostream &, const BigIntNums &);
    friend istream &operator>>(istream &, BigIntNums &);
    friend BigIntNums operator-(const BigIntNums &);
    friend BigIntNums operator+(const BigIntNums &, const BigIntNums &);
    friend BigIntNums operator*(const BigIntNums &, const BigIntNums &);
    friend BigIntNums operator-(const BigIntNums &, const BigIntNums &);
    friend BigIntNums operator/(const BigIntNums &, const BigIntNums &);
    friend BigIntNums operator%(const BigIntNums &, const BigIntNums &);
    friend bool operator<(const BigIntNums &, const BigIntNums &);
    friend bool operator>(const BigIntNums &, const BigIntNums &);
    friend bool operator<=(const BigIntNums &, const BigIntNums &);
    friend bool operator>=(const BigIntNums &, const BigIntNums &);
    friend bool operator==(const BigIntNums &, const BigIntNums &);
    friend bool operator!=(const BigIntNums &, const BigIntNums &);
public:
    BigIntNums() = default;
    BigIntNums(const BigIntNums &);
    BigIntNums(const string &);
    BigIntNums(const int &);
    BigIntNums(const unsigned int &);
    BigIntNums(const long long &);
    BigIntNums(const unsigned long long &);

    operator bool();
    BigIntNums &operator++();
    BigIntNums &operator--();
    BigIntNums &operator=(const BigIntNums &);
    BigIntNums &operator+=(const BigIntNums &);
    BigIntNums &operator*=(const BigIntNums &);
    BigIntNums &operator-=(const BigIntNums &);
    BigIntNums &operator/=(const BigIntNums &);
    string getStr();
private:
    static constexpr size_t gap_ = 10000;
    static constexpr size_t base_ = 10;

    std::vector<int> numMem;
    bool npFlag = true;

    void combineStrToBigInt(const string &);
    template<typename T>void loadNums(T);
    void clear();
};

template<typename T>void BigIntNums::loadNums(T num)
{
    numMem.clear();
    while (num / gap_)
    {
        numMem.push_back(static_cast<int>(num%gap_));
        num /= gap_;
    }
    numMem.push_back(static_cast<int>(num));
}

#endif // BigIntNums_H

#include "bigIntNum.h"

ostream &operator<<(ostream &os, const BigIntNums &num)
{
    if (num.npFlag == false)
        os << '-';
    os << num.numMem[num.numMem.size() - 1] << " ";
    os << setfill('0') << right;
    int cut = static_cast<int>(log10(BigIntNums::gap_));
    for(int i = num.numMem.size() - 2;i >=0 ;i--)
        os << setw(cut) << num.numMem[i] << " ";
    os << setfill(' ') << left;
    return os;
}

istream &operator>>(istream &is, BigIntNums &num)
{
    num.clear();
    string str;
    is >> str;
    num.combineStrToBigInt(str);
    return is;
}

BigIntNums::BigIntNums(const BigIntNums &ob)
    :numMem(ob.numMem)
    , npFlag(ob.npFlag)
{ }

BigIntNums::BigIntNums(const int &num)
{
    loadNums(num);
    npFlag = num >= 0 ? true : false;
}

BigIntNums::BigIntNums(const unsigned int &num)
{
    loadNums(num);
    npFlag = true;
}

BigIntNums::BigIntNums(const long long &num)
{
    loadNums(num);
    npFlag = num >= 0 ? true : false;
}

BigIntNums::BigIntNums(const unsigned long long &num)
{
    loadNums(num);
    npFlag = true;
}

BigIntNums::BigIntNums(const string &str_org)
{
    combineStrToBigInt(str_org);
}

inline void BigIntNums::clear()
{
    numMem.clear();
    npFlag = true;
}

void BigIntNums::combineStrToBigInt(const string &str_org)
{
    int base_Count = static_cast<int>(log10(BigIntNums::gap_));

    string str = str_org;
    reverse(str.begin(), str.end());
    if (!isalnum(str.back()))
    {
        npFlag = str.back() == '+' ? 1 : 0;
        str.pop_back();
    }
    int cnt = str.size() - base_Count, i;
    for (i = 0; i < cnt; i += 4)
    {
        string cast = str.substr(i, base_Count);
        reverse(cast.begin(), cast.end());
        int tmp = atoi(cast.c_str());
        numMem.push_back(tmp);
    }
    string cast = str.substr(i, str.size());
    reverse(cast.begin(), cast.end());
    int tmp = atoi(cast.c_str());
    numMem.push_back(tmp);
}

string BigIntNums::getStr()
{
    string tmp;

    for (auto i = numMem.crbegin();i != numMem.crend();++i)
    {
        stringstream cast;
        cast << *i;
        tmp += cast.str();
    }
    return tmp;
}

BigIntNums::operator bool()
{
    return *this != BigIntNums(0);
}

bool operator==(const BigIntNums &A, const BigIntNums &B)
{
    if (A.npFlag != B.npFlag)
        return false;
    else if (A.numMem.size() != B.numMem.size())
        return false;
    else
    {
        for (int i = 0;i < A.numMem.size();i++)
            if (A.numMem[i] != B.numMem[i])
                return false;
    }
    return true;
}

bool operator!=(const BigIntNums &A, const BigIntNums &B)
{
    return !(A == B);
}

bool operator<(const BigIntNums &A, const BigIntNums &B)
{
    if (A.npFlag == true && B.npFlag == false)
        return false;
    else if (A.npFlag == false && B.npFlag == true)
        return true;
    else
    {
        auto ret = A.npFlag && B.npFlag;
        if (A.numMem.size() > B.numMem.size())
            return !ret;
        else if (A.numMem.size() < B.numMem.size())
            return ret;
        else if (A.numMem.size() == B.numMem.size())
        {
            for (int i = A.numMem.size() - 1;i >= 0;i--)
            {
                if (A.numMem[i] > B.numMem[i])
                    return !ret;
                else if (A.numMem[i] < B.numMem[i])
                    return ret;
            }
        }
        return false;//相等
    }
}

bool operator>(const BigIntNums &A, const BigIntNums &B)
{
    if (A.npFlag == false && B.npFlag == true)
        return false;
    else if (A.npFlag == true && B.npFlag == false)
        return true;
    else
    {
        auto ret = A.npFlag && B.npFlag;
        if (A.numMem.size() > B.numMem.size())
            return ret;
        else if (A.numMem.size() < B.numMem.size())
            return !ret;
        else if (A.numMem.size() == B.numMem.size())
        {
            for (int i = A.numMem.size() - 1;i >= 0;i--)
            {
                if (A.numMem[i] > B.numMem[i])
                    return ret;
                else if (A.numMem[i] < B.numMem[i])
                    return !ret;
            }
        }
        return false;//相等
    }
}

bool operator<=(const BigIntNums &A, const BigIntNums &B)
{
    return  A < B || A == B;
}

bool operator>=(const BigIntNums &A, const BigIntNums &B)
{
    return A > B || A == B;
}

BigIntNums abs(const BigIntNums &i)
{
    return i >= 0 ? i : -i;
}

BigIntNums operator-(const BigIntNums &num)
{
    BigIntNums newNum(num);
    newNum.npFlag = !num.npFlag;
    return newNum;
}

BigIntNums operator+(const BigIntNums &A, const BigIntNums &B)
{
    BigIntNums C;

    if (A.npFlag == true && B.npFlag == true)
        C.npFlag = true;
    else if (A.npFlag == false && B.npFlag == false)
        C.npFlag = false;
    else if (A.npFlag == true && B.npFlag == false)
        return A - (-B);
    else if (A.npFlag == false && B.npFlag == true)
        return B - (-A);

    std::vector<int> &CM = C.numMem;
    const std::vector<int> &AM = A.numMem, &BM = B.numMem;

    int up = 0, tmp;
    size_t cnt = std::min(A.numMem.size(), B.numMem.size()), i = 0;

    for (;i < cnt; i++)
    {
        tmp = AM[i] + BM[i] + up;
        CM.push_back(tmp % BigIntNums::gap_);
        up = tmp / BigIntNums::gap_;
    }
    //要注意可能会出现1+999999999999999999999999999的情况
    for (;i < AM.size(); i++)
    {
        tmp = AM[i] + up;
        CM.push_back((AM[i] + up) % BigIntNums::gap_);
        up = (AM[i] + up) / BigIntNums::gap_;
    }
    for (;i < BM.size(); i++)
    {
        tmp = BM[i] + up;
        CM.push_back((BM[i] + up) % BigIntNums::gap_);
        up = (BM[i] + up) / BigIntNums::gap_;
    }
    if(up)
        CM.push_back(up);
    return C;
}

BigIntNums operator-(const BigIntNums &A, const BigIntNums &B)
{
    BigIntNums C;
    C.npFlag = true;
    if (A.npFlag == true && B.npFlag == true && A < B)
    {
        C = B - A;
        C.npFlag = false;
        return C;
    }
    else if (A.npFlag == false && B.npFlag == false)
        return (-B) - (-A);
    else if (A.npFlag == true && B.npFlag == false)
        return A + (-B);
    else if (A.npFlag == false && B.npFlag == true)
    {
        C = (-A) + B;
        C.npFlag = false;
        return C;
    }    
        
    std::vector<int> &CM = C.numMem;
    const std::vector<int> &AM = A.numMem, &BM = B.numMem;

    int down = 0,  tmp;
    size_t cnt = B.numMem.size(), i = 0;

    for (;i < cnt; i++)
    {
        if (AM[i] - BM[i] - down >= 0)
        {
            tmp = AM[i] - BM[i] - down;
            down = 0;
        }
        else
        {
            tmp = BigIntNums::gap_ + AM[i] - BM[i] - down;
            down = 1;
        }
        CM.push_back(tmp);
    }
    //注意1000000000000000-1的情况
    for (;i < A.numMem.size();i++)
    {
        if (AM[i] - down >= 0)
        {
            tmp = AM[i] - down;
            down = 0;
        }
        else
        {
            tmp = BigIntNums::gap_ + AM[i] - down;
            down = 1;
        }
        CM.push_back(tmp);
    }
    while(C.numMem.back() == 0 && CM.size() != 1)
        //如果只剩下0，那还是要保留0
        C.numMem.pop_back();
    return C;
}

BigIntNums operator*(const BigIntNums &A, const BigIntNums &B)
{
    BigIntNums C;
    C.npFlag = true;

    if (A.npFlag == false && B.npFlag == true
        || A.npFlag == true && B.npFlag == false)
        C.npFlag = false;
    
    if (abs(A) < abs(B))
        return B*A;

    if (A == 0 || B == 0)
        return BigIntNums(0);

    const std::vector<int> &AM = A.numMem, &BM = B.numMem;
    std::vector<int> &CM = C.numMem;

    int up = 0, tmp;

    for (int i = 0; i < AM.size();i++,up = 0)
    {
        for (int j = 0; j < BM.size();j++)
        {
            tmp = AM[i] * BM[j] + up;
            if (i + j < CM.size())
            {
                up = (tmp + CM[i + j]) / BigIntNums::gap_;
                CM[i + j] = (tmp + CM[i + j]) % BigIntNums::gap_;
            }    
            else
            {
                up = tmp / BigIntNums::gap_;
                CM.push_back(tmp % BigIntNums::gap_);
            }
        }
        if (up)
            CM.push_back(up);
    }
    return C;
}

BigIntNums operator/(const BigIntNums &A, const BigIntNums &B)
{
    int base_Count = static_cast<int>(log10(BigIntNums::gap_));

    if (abs(A) < abs(B))
        return BigIntNums(0);
    BigIntNums C;
    C.npFlag = true;

    if (A.npFlag == false && B.npFlag == true
        || A.npFlag == true && B.npFlag == false)
        C.npFlag = false;

    int base_Map, tmp;
    std::vector<int> rCM;
    std::vector<int> &CM = C.numMem;
    const std::vector<int> &AM = A.numMem, &BM = B.numMem;
    BigIntNums dividend = 0, divisor;
    auto CM_Iter = CM.rbegin();

    for (int i = AM.size() - 1; i >= 0;)
    {
        do {
            dividend *= static_cast<int>(pow(BigIntNums::base_, base_Count));
            dividend += AM[i--];
        } while (dividend < B && i >= 0);
            
        tmp = 0;
        for (int j = base_Count - 1;j >= 0;j--)
        {
            for (int k = BigIntNums::base_ - 1;;k--)
            {
                base_Map = static_cast<int>(pow(BigIntNums::base_, j)) * k;
                auto tmp = abs(B);
                BigIntNums y = tmp * BigIntNums(base_Map);
                if (y <= dividend)
                    break;
            }
            dividend -= abs(B) * BigIntNums(base_Map);
            tmp += base_Map;
        }
        rCM.push_back(tmp);
    }
    for (auto i = rCM.crbegin();i != rCM.crend();++i)
        CM.push_back(*i);
    while (C.numMem.back() == 0 && CM.size() != 1)
        C.numMem.pop_back();

    return C;
}

BigIntNums operator%(const BigIntNums &A, const BigIntNums &B)
{
    auto ret = A / B;
    return A - ret*B;
}

BigIntNums &BigIntNums::operator++()
{
    *this = *this + BigIntNums(1);
    return *this;
}

BigIntNums &BigIntNums::operator--()
{
    *this = *this - BigIntNums(1);
    return *this;
}

BigIntNums &BigIntNums::operator=(const BigIntNums &ob)
{
    if (&ob != this)
    {
        this->numMem = ob.numMem;
        this->npFlag = ob.npFlag;
    }
    return *this;
}

BigIntNums &BigIntNums::operator+=(const BigIntNums &ob)
{
    *this = *this + ob;
    return *this;
}

BigIntNums &BigIntNums::operator-=(const BigIntNums &ob)
{
    *this = *this - ob;
    return *this;
}

BigIntNums &BigIntNums::operator*=(const BigIntNums &ob)
{
    *this = *this * ob;
    return *this;
}

BigIntNums &BigIntNums::operator/=(const BigIntNums &ob)
{
    *this = *this / ob;
    return *this;
}