C++大数模板

 模板一：

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

struct BigInteger {
    static const int D = 10000;
    typedef vector<int> DigSet;

    enum Sign {positive, negative} sign;
    DigSet dig;
    BigInteger(const DigSet& dig = DigSet(), Sign sign = positive):sign(sign),dig(dig){}
    BigInteger(LL val):sign(val>=0?positive:negative) {
        val = abs(val);
        while (val) {
            dig.push_back(val%D);
            val /= D;
        }
    }
    BigInteger(const string& val) {
        for (int i = val.size() - 1; i >= 0; i-=4) {
            int d = 0;
            for (int j = 0, p=1; j < 4 && i - j >= 0 && isdigit(val[i - j]); j++, p*=10) {
                d += (val[i-j] & 0xf)*p;
            }
            dig.push_back(d);
        }
        sign = Sign(val[0] == '-');
        purify();
    }
    string toString() const {
        if (zero()) return "0";
        string rst;
        if (sign==negative) rst = "-";
        rst += to_string(highest());
        for (int i = 2; i <= dig.size(); i++) {
            static char buf[10];
            sprintf(buf, "%04d", highest(i));
            rst += buf;
        }
        return rst;
    }
    friend istream& operator>> (istream& is, BigInteger& x) {
        string s;
        is >> s;
        x = s;
        return is;
    }
    friend ostream& operator<< (ostream& os, const BigInteger& x) {
        os << x.toString();
        return os;
    }

    int highest(int i=1) const {
        return dig[dig.size() - i];
    }
    bool zero() const {
        return dig.empty();
    }
    BigInteger& purify() {
        if (zero()) {
            sign = positive;
            return *this;
        }
        for (int i = 0; i < dig.size()-1; i++) {
            dig[i + 1] += dig[i] / D;
            dig[i] %= D;
            if (dig[i] < 0) {
                dig[i + 1]--;
                dig[i] += D;
            }
        }
        while (highest() >= D) {
            dig.push_back(highest() / D);
            dig[dig.size() - 2] %= D;
        }
        while (!zero() && !highest()) {
            dig.pop_back();
        }
        if (zero()) {
            sign = positive;
        }
        return *this;
    }


    static DigSet add(const DigSet& x, const DigSet& y) {
        DigSet rst = x.size() > y.size() ? x : y;
        const DigSet& less = x.size() > y.size() ? y : x;
        for (int i = 0; i < less.size(); i++) {
            rst[i] += less[i];
        }
        return rst;
    }
    static DigSet sub(DigSet x, const DigSet& y) {
        for (int i = 0; i < y.size(); i++) {
            x[i] -= y[i];
        }
        return x;
    }
    static int cmp(const DigSet& x, const DigSet& y) {
        if (x.size() < y.size()) return -1;
        else if (x.size() > y.size()) return 1;
        for (int i = x.size()-1; i >= 0; i--) {
            if (x[i] < y[i]) return -1;
            else if (x[i] > y[i]) return 1;
        }
        return 0;
    }
    bool operator< (const BigInteger& b) const {
        if (sign != b.sign) return sign==negative;
        else return cmp(dig, b.dig) == (int)sign*2-1;
    }
    bool operator== (const BigInteger& b) const {
        return sign == b.sign && cmp(dig, b.dig) == 0;
    }
    bool operator<= (const BigInteger& b) const {
        return *this == b || *this < b;
    }
    BigInteger operator+ (const BigInteger& b) const {
        if (sign == b.sign) {
            return BigInteger(add(dig, b.dig), sign).purify();
        }
        else {
            return *this- -b;
        }
    }
    BigInteger operator-() const {
        return BigInteger(dig, (Sign)!sign);
    }
    BigInteger operator-(const BigInteger& b) const {
        if (sign == b.sign) {
            int c = cmp(dig, b.dig);
            if (c == 0) return BigInteger().purify();
            else if (c == 1) return BigInteger(sub(dig, b.dig), sign).purify();
            else return BigInteger(sub(b.dig, dig), (Sign)!sign).purify();
        }
        else {
            return *this+ -b;
        }
    }
    BigInteger operator*(const BigInteger& b) const {
        BigInteger rst(DigSet(dig.size() + b.dig.size()), Sign(sign!=b.sign));
        for (int i = 0; i < dig.size(); i++) {
            for (int j = 0; j < b.dig.size(); j++) {
                rst.dig[i + j] += dig[i] * b.dig[j];
                rst.dig[i + j + 1] += rst.dig[i + j] / D;
                rst.dig[i + j] %= D;
            }
        }
        return rst.purify();
    }
    BigInteger operator/ (const BigInteger& b) const {
        BigInteger rst(DigSet(dig.size()), Sign(sign != b.sign));
        BigInteger div;
        for (int i = dig.size()-1; i>=0; i--) {
            div = div * D + dig[i];
            BigInteger mul(b.dig, positive);
            for (int j = 0x2000; j; j >>= 1) {
                if (mul*j <= div) {
                    rst.dig[i] |= j;
                    div = div - mul * j;
                }
            }
        }
        return rst.purify();
    }
    BigInteger operator% (const BigInteger& b) const {
        BigInteger rst = *this - *this / b * b;
        return rst.sign == positive ? rst : b.sign == positive ? rst + b : rst - b;
    }
};

int main() {
    BigInteger a, b;
    while (cin >> a >> b) {
        cout << a + b << endl;
        cout << a - b << endl;
        cout << a * b << endl;
        if (!(b == 0)) {
            cout << a / b << endl;
            cout << a % b << endl;
        }
    }
    return 0;
}

模板二：(比上面那个要快一点)

#include <bits/stdc++.h>
using namespace std;

//大数
struct BigInteger
{
    static const int BASE = 100000000; //和WIDTH保持一致
    static const int WIDTH = 8;        //八位一存储,如修改记得修改输出中的%08d
    bool sign;                         //符号, 0表示负数
    size_t length;                     //位数
    vector<int> num;                   //反序存
                                       //构造函数
    BigInteger(long long x = 0) { *this = x; }
    BigInteger(const string &x) { *this = x; }
    BigInteger(const BigInteger &x) { *this = x; }
    //剪掉前导0，并且求一下数的位数
    void cutLeadingZero()
    {
        while (num.back() == 0 && num.size() != 1)
        {
            num.pop_back();
        }
        int tmp = num.back();
        if (tmp == 0)
        {
            length = 1;
        }
        else
        {
            length = (num.size() - 1) * WIDTH;
            while (tmp > 0)
            {
                length++;
                tmp /= 10;
            }
        }
    }
    //赋值运算符
    BigInteger &operator=(long long x)
    {
        num.clear();
        if (x >= 0)
        {
            sign = true;
        }
        else
        {
            sign = false;
            x = -x;
        }
        do
        {
            num.push_back(x % BASE);
            x /= BASE;
        } while (x > 0);
        cutLeadingZero();
        return *this;
    }
    BigInteger &operator=(const string &str)
    {
        num.clear();
        sign = (str[0] != '-'); //设置符号
        int x, len = (str.size() - 1 - (!sign)) / WIDTH + 1;
        for (int i = 0; i < len; i++)
        {
            int End = str.size() - i * WIDTH;
            int start = max((int)(!sign), End - WIDTH); //防止越界
            sscanf(str.substr(start, End - start).c_str(), "%d", &x);
            num.push_back(x);
        }
        cutLeadingZero();
        return *this;
    }
    BigInteger &operator=(const BigInteger &tmp)
    {
        num = tmp.num;
        sign = tmp.sign;
        length = tmp.length;
        return *this;
    }
    //绝对值
    BigInteger abs() const
    {
        BigInteger ans(*this);
        ans.sign = true;
        return ans;
    }
    //正号
    const BigInteger &operator+() const { return *this; }
    //负号
    BigInteger operator-() const
    {
        BigInteger ans(*this);
        if (ans != 0)
            ans.sign = !ans.sign;
        return ans;
    }
    // + 运算符
    BigInteger operator+(const BigInteger &b) const
    {
        if (!b.sign)
        {
            return *this - (-b);
        }
        if (!sign)
        {
            return b - (-*this);
        }
        BigInteger ans;
        ans.num.clear();
        for (int i = 0, g = 0;; i++)
        {
            if (g == 0 && i >= num.size() && i >= b.num.size())
                break;
            int x = g;
            if (i < num.size())
                x += num[i];
            if (i < b.num.size())
                x += b.num[i];
            ans.num.push_back(x % BASE);
            g = x / BASE;
        }
        ans.cutLeadingZero();
        return ans;
    }
    // - 运算符
    BigInteger operator-(const BigInteger &b) const
    {
        if (!b.sign)
        {
            return *this + (-b);
        }
        if (!sign)
        {
            return -((-*this) + b);
        }
        if (*this < b)
        {
            return -(b - *this);
        }
        BigInteger ans;
        ans.num.clear();
        for (int i = 0, g = 0;; i++)
        {
            if (g == 0 && i >= num.size() && i >= b.num.size())
                break;
            int x = g;
            g = 0;
            if (i < num.size())
                x += num[i];
            if (i < b.num.size())
                x -= b.num[i];
            if (x < 0)
            {
                x += BASE;
                g = -1;
            }
            ans.num.push_back(x);
        }
        ans.cutLeadingZero();
        return ans;
    }
    // * 运算符
    BigInteger operator*(const BigInteger &b) const
    {
        int lena = num.size(), lenb = b.num.size();
        BigInteger ans;
        for (int i = 0; i < lena + lenb; i++)
            ans.num.push_back(0);
        for (int i = 0, g = 0; i < lena; i++)
        {
            g = 0;
            for (int j = 0; j < lenb; j++)
            {
                long long x = ans.num[i + j];
                x += (long long)num[i] * (long long)b.num[j];
                ans.num[i + j] = x % BASE;
                g = x / BASE;
                ans.num[i + j + 1] += g;
            }
        }
        ans.cutLeadingZero();
        ans.sign = (ans.length == 1 && ans.num[0] == 0) || (sign == b.sign);
        return ans;
    }
    //*10^n 大数除大数中用到
    BigInteger e(size_t n) const
    {
        int tmp = n % WIDTH;
        BigInteger ans;
        ans.length = n + 1;
        n /= WIDTH;
        while (ans.num.size() <= n)
            ans.num.push_back(0);
        ans.num[n] = 1;
        while (tmp--)
            ans.num[n] *= 10;
        return ans * (*this);
    }
    // /运算符 (大数除大数)
    BigInteger operator/(const BigInteger &b) const
    {
        BigInteger aa((*this).abs());
        BigInteger bb(b.abs());
        if (aa < bb)
            return 0;
        char *str = new char[aa.length + 1];
        memset(str, 0, sizeof(char) * (aa.length + 1));
        BigInteger tmp;
        int lena = aa.length, lenb = bb.length;
        for (int i = 0; i <= lena - lenb; i++)
        {
            tmp = bb.e(lena - lenb - i);
            while (aa >= tmp)
            {
                str[i]++;
                aa = aa - tmp;
            }
            str[i] += '0';
        }
        BigInteger ans(str);
        delete[] str;
        ans.sign = (ans == 0 || sign == b.sign);
        return ans;
    }
    // %运算符
    BigInteger operator%(const BigInteger &b) const
    {
        return *this - *this / b * b;
    }
    // ++ 运算符
    BigInteger &operator++()
    {
        *this = *this + 1;
        return *this;
    }
    // -- 运算符
    BigInteger &operator--()
    {
        *this = *this - 1;
        return *this;
    }
    // += 运算符
    BigInteger &operator+=(const BigInteger &b)
    {
        *this = *this + b;
        return *this;
    }
    // -= 运算符
    BigInteger &operator-=(const BigInteger &b)
    {
        *this = *this - b;
        return *this;
    }
    // *=运算符
    BigInteger &operator*=(const BigInteger &b)
    {
        *this = *this * b;
        return *this;
    }
    // /= 运算符
    BigInteger &operator/=(const BigInteger &b)
    {
        *this = *this / b;
        return *this;
    }
    // %=运算符
    BigInteger &operator%=(const BigInteger &b)
    {
        *this = *this % b;
        return *this;
    }
    // < 运算符
    bool operator<(const BigInteger &b) const
    {
        if (sign != b.sign) //正负，负正
        {
            return !sign;
        }
        else if (!sign && !b.sign) //负负
        {
            return -b < -*this;
        }
        //正正
        if (num.size() != b.num.size())
            return num.size() < b.num.size();
        for (int i = num.size() - 1; i >= 0; i--)
            if (num[i] != b.num[i])
                return num[i] < b.num[i];
        return false;
    }
    bool operator>(const BigInteger &b) const { return b < *this; }                     // >  运算符
    bool operator<=(const BigInteger &b) const { return !(b < *this); }                 // <= 运算符
    bool operator>=(const BigInteger &b) const { return !(*this < b); }                 // >= 运算符
    bool operator!=(const BigInteger &b) const { return b < *this || *this < b; }       // != 运算符
    bool operator==(const BigInteger &b) const { return !(b < *this) && !(*this < b); } //==运算符
    // 逻辑运算符
    bool operator||(const BigInteger &b) const { return *this != 0 || b != 0; } // || 运算符
    bool operator&&(const BigInteger &b) const { return *this != 0 && b != 0; } // && 运算符
    bool operator!() { return (bool)(*this == 0); }                             // ！ 运算符

    //重载<<使得可以直接输出大数
    friend ostream &operator<<(ostream &out, const BigInteger &x)
    {
        if (!x.sign)
            out << '-';
        out << x.num.back();
        for (int i = x.num.size() - 2; i >= 0; i--)
        {
            char buf[10];
            //如WIDTH和BASR有变化,此处要修改为%0(WIDTH)d
            sprintf(buf, "%08d", x.num[i]);
            for (int j = 0; j < strlen(buf); j++)
                out << buf[j];
        }
        return out;
    }
    //重载>>使得可以直接输入大数
    friend istream &operator>>(istream &in, BigInteger &x)
    {
        string str;
        in >> str;
        size_t len = str.size();
        int start = 0;
        if (str[0] == '-')
            start = 1;
        if (str[start] == '\0')
            return in;
        for (int i = start; i < len; i++)
        {
            if (str[i] < '0' || str[i] > '9')
                return in;
        }
        x.sign = !start;
        x = str.c_str();
        return in;
    }
};

int main()
{
    BigInteger a, b;
    cin>>a>>b;
    while(a!=b)
	{
		if(a>b)
			a-=b;
		else
			b-=a;
	}
	cout<<a<<endl;
    return 0;
}