自己动手写的大数模板

/*
一般将算数和关系操作符定义为非成员函数，而将赋值操作符定义为成员:

*/


#include<iostream>
#include<string>
#include<sstream>
#include<cmath>     //pow()
#include<cstdlib>   //system("PAUSE");
#include<cassert>
using namespace std;

class BigNum
{
public:
    string s;
    string str() const;
    BigNum ();
    BigNum (const string& n);
    BigNum (const int& n);
    BigNum (const char* n);

    friend std::istream& operator >> (std::istream&, BigNum& );
    friend std::ostream& operator << (std::ostream&, BigNum& );

    BigNum& operator = (const string& n);
    BigNum& operator = (const int& n);
    BigNum& operator = (const char* n);

    friend BigNum operator + (const BigNum& , const BigNum& );
    friend BigNum operator - (const BigNum& , const BigNum& );
    friend BigNum operator * (const BigNum& , const BigNum& );
    friend BigNum operator / (const BigNum& , const BigNum& );
    friend BigNum operator % (const BigNum& , const BigNum& );

    BigNum& operator += (const BigNum& );
    BigNum& operator -= (const BigNum& );
    BigNum& operator *= (const BigNum& );
    BigNum& operator /= (const BigNum& );
    BigNum& operator %= (const BigNum& );
};
//*******************************************************

string BigNum::str() const
{
    string res(s.rbegin(), s.rend());
    if(res == "")
        res = "0";
    return res;
}
BigNum& BigNum::operator = (const string& n)
{
    s = string(n.rbegin(), n.rend());
    return *this;
}
BigNum& BigNum::operator = (const int& n)
{
    stringstream ss;
    ss << n;
    ss >> s;
    s = string(s.rbegin(), s.rend());
    return *this;
}
BigNum& BigNum::operator = (const char* n)
{
    s = string(n);
    s = string(s.rbegin(), s.rend());;
    return *this;
}
//*******************************************************
BigNum::BigNum()
{
    s = "";
}
BigNum::BigNum (const string& n)
{
   *this = n;
}
BigNum::BigNum (const int& n)
{
    *this = n;
}
BigNum::BigNum(const char* n)
{
    *this = n;
}

//*******************************************************
std::istream& operator >> (std::istream& in, BigNum& x)
{
    string s;
    in >> s;
    x = s;
    return in;
}
string del_pre_zero(const string& a)
{
    int i = 0;
    for(; a[i] == '0' && i != a.size(); ++i);
    if(i == a.size())
        return "0";
    string t(a.begin() + i, a.end());
    return t;
}
std::ostream& operator << (std::ostream& out, BigNum& x)
{
    out << del_pre_zero(x.str());
    return out;
}
//*******************************************************

bool is_not_small(const string& a, const string& b)
{
    if(a.size() != b.size())
        return a.size() > b.size();
    return a >= b;
}


//*******************************************************

BigNum operator + (const BigNum& x, const BigNum& y)
{
    BigNum res;
    string& result = res.s;
    const string& a = x.s;
    const string& b = y.s;
    int i, c;
    i = c = 0;
    for(; i < a.size() && i < b.size(); ++i)
    {
        c += (a[i] - '0') + (b[i] - '0');
        result += (c % 10 + '0');
        c /= 10;
    }
    while(i < a.size())
    {
        c += (a[i] - '0');
        result += (c % 10 + '0');
        c /= 10;
        ++i;
    }
    while(i < b.size())
    {
        c += (b[i] - '0');
        result += (c % 10 + '0');
        c /= 10;
        ++i;
    }
    if(c)
        result += (c + '0');
    return res;
}
BigNum operator - (const BigNum& x, const BigNum& y)
{
    const string& a = x.s;
    const string& b = y.s;
    string x1(a), y1(b);
    bool flag = true;
    if(!is_not_small(x1, y1))
    {
        flag = false;
        string t(a);
        x1 = y1;
        y1 = t;
    }
    int i, cur, c;
    i = cur = c = 0;
    BigNum res;
    string& result = res.s;
    for(; i != y1.size(); ++i)
    {
        cur = x1[i] - y1[i] + c;
        (cur < 0) ? (cur += 10, c = -1) : (c = 0);
        result += (cur + '0');
    }
    while(i < x1.size())
    {
        cur = x1[i] - '0' + c;
        (cur < 0) ? (cur += 10, c = -1) : (c = 0);
        result += (cur + '0');
        ++i;
    }
    if(!flag)
        result = result + "-";
    return res;
}

BigNum operator * (const BigNum& x, const BigNum& y)
{
    if(x.s == "0" || y.s == "0")
        return "0";
    string a(x.s), b(y.s);
    if(a.size() > b.size())
    {
        string t(a);
        a = b;
        b = t;
    }
    BigNum res;
    string& result = res.s;
    result = "0";
    int c;
    for(int i = 0; i != a.size(); ++i)
    {
        string sum(i, '0');
        c = 0;
        for(int j = 0; j != b.size(); ++j)
        {
            c += (a[i] - '0') * (b[j] - '0');
            sum += (c % 10 + '0');
            c /= 10;
        }
        while(c)
        {
            sum += (c%10 + '0');
            c /= 10;
        }
        result = (BigNum(string(result.rbegin(), result.rend())) + BigNum(string(sum.rbegin(), sum.rend()))).s;
    }
    return res;
}

BigNum operator / (const BigNum& x, const BigNum& y)
{
    assert(y.s != "0");
    const string& a = x.s;
    const string& b = y.s;
    if(!is_not_small(a, b))
        return "0";
    if(a == b)
        return "1";
    string x_s(a), y_s;
    int n, tot;
    n = tot = 0;
    while(is_not_small(x_s, b))
    {
        n = x_s.size() - b.size();
        if(*(x_s.rbegin()) < *(b.rbegin()))
            --n;
            if(n < 0)
                n == 0;
        string zero(n, '0');
        y_s = zero + b;
        x_s = (BigNum(string(x_s.rbegin(), x_s.rend())) - BigNum(string(y_s.rbegin(), y_s.rend()))).s;
        int i = x_s.size() - 1;
        for(; i >= 0 && x_s[i] == '0'; --i);
        if(i < 0)
            x_s = "0";
        else
            x_s = string(x_s.begin(), x_s.begin() + i + 1);
        tot += pow(10, n);
        //system("PAUSE");
    }
    stringstream ss;
    ss << tot;
    BigNum res;
    string& result = res.s;
    ss >> result;
    result = string(result.rbegin(), result.rend());
    return res;
}
BigNum operator % (const BigNum& x, const BigNum& y)
{
    assert(y.s != "0");
    const string& a = x.s;
    const string& b = y.s;
    if(!is_not_small(a, b))
        return x;
    if(a == b)
        return "0";
        BigNum res;
        string& x_s = res.s;
        x_s = a;
    string y_s;
    int n = 0;
    while(is_not_small(x_s, b))
    {
        n = x_s.size() - b.size();
        if(*(x_s.rbegin()) < *(b.rbegin()))
            --n;
        string zero(n, '0');
        y_s = zero + b;
        x_s = (BigNum(string(x_s.rbegin(), x_s.rend())) - BigNum(string(y_s.rbegin(), y_s.rend()))).s;
        int i = x_s.size() - 1;
        for(; i >= 0 && x_s[i] == '0'; --i);
        if(i < 0)
            x_s = "0";
        else
            x_s = string(x_s.begin(), x_s.begin() + i + 1);
        //system("PAUSE");
    }
    return res;
}
//*******************************************************

BigNum& BigNum::operator += (const BigNum& x)
{
    *this = *this + x;
    return *this;
}
BigNum& BigNum::operator -= (const BigNum& x)
{
    *this = *this - x;
    return *this;
}
BigNum& BigNum::operator *= (const BigNum& x)
{
    *this = *this * x;
    return *this;
}

BigNum& BigNum::operator /= (const BigNum& x)
{
    *this = *this / x;
    return *this;
}
BigNum& BigNum::operator %= (const BigNum& x)
{
    *this = *this % x;
    return *this;
}
//*******************************************************
int main()
{
    BigNum a, b, result;
    while(cin >> a >> b)
    {
        result = a + b ;
        cout << result << endl;
        result = a - b ;
        cout << result << endl;
        result = a * b ;
        cout << result << endl;
        result = a / b ;
        cout << result << endl;
        result = a % b;
        cout << result << endl;
    }
    return 0;
}

大数就先告一段落了，其他的就在