洛谷 p1601 A+B Promblem(高精)

来一发重载运算符的高精度，重载运算符的练手题。

重载运算符的高精度看起来代码长，但是很实用，可以支持sort、map等操作，特别特别方便。

用的是vector，其实不比数组慢多少，而且动态数组不用根据内存手动调数组大小。

Ac代码：

---

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<vector>
#include<cstring> 
#include<string>
using namespace std;
struct BigInteger {
    static const int BASE = 100000000;//压位高精，1e8把一个int的空间塞得满满的
    static const int WIDTH = 8;
//静态成员变量，在结构体中使用，很好的避免了重名的问题。
//在其他地方使用要加上结构体的名字，BigInteger::BASE
    vector<int> s;

//构造函数
    BigInteger(long long num = 0) { *this = num; }
//将一个整数赋值给大整数类型的变量
    BigInteger operator = (long long num) {
        s.clear();
        do {
            s.push_back(num % BASE);
            num /= BASE;
        } while(num > 0);
        return *this;
    }
//将一个字符串赋值给大整数类型的变量
    BigInteger operator = (const string& str) {
        s.clear();
        int x, len = (str.length() - 1) / WIDTH + 1;
        for(int i = 0; i < len; ++i) {
            int end = str.length() - i*WIDTH;
            int start = max(0, end - WIDTH);
            sscanf(str.substr(start, end - start).c_str(), "%d", &x);
            //成员函数c_str()将string变为char数组
            s.push_back(x);
        }
        return *this;
    }

//重载 + 运算
//压位的高精其实就是把原来的/10、%10变成了/BASE
    BigInteger operator + (const BigInteger& b) const {
        BigInteger c;
        c.s.clear();
        for(int i = 0, g = 0; ; ++i) {
            if(g == 0 && i >= s.size() && i>=b.s.size()) break;
            int x = g;
            if(i < s.size()) x += s[i];
            if(i < b.s.size()) x += b.s[i];
            c.s.push_back(x % BASE);
            g = x / BASE;
        }
        return c;
    }
//顺便重载一下 += 运算
    BigInteger operator += (const BigInteger& b) {
        *this = *this + b;
        return *this;
    }

//重载 < 运算
    bool operator < (const BigInteger& b) const {
        if(s.size() != b.s.size()) return s.size() < b.s.size();
        for(int i = s.size()-1; i >= 0; --i)
            if(s[i] != b.s[i]) return s[i] < b.s[i];
        return false;//相等的情况也不是小于
    }
//重载 == 运算
//判断两个BigInteger类型变量是否相等
    bool operator == (const BigInteger& b) const {
        return !(b < *this) && !(*this < b);
    }
};

//重载 << 和 >> 运算，放在结构体的外面
//放在结构体里面前面要加friend
//就像
//friend ostream& operator << ...
ostream& operator << (ostream &out, const BigInteger& x) {
    out << x.s.back();
    for(int i = x.s.size()-2; i>=0; --i) {
        char buf[21];
        sprintf(buf, "%08d", x.s[i]);
        int buf_len = strlen(buf);
        for(int j = 0; j < buf_len; ++j)
            out << buf[j];
    }
    return out;
}
istream& operator >> (istream &in, BigInteger& x) {
    string s;
    if(!(in >> s)) return in;
    x = s;
    return in;
}

int main() {
    BigInteger a, b, c = 0;
    cin >> a >> b;
//有多余的前导0的情况要特判
    if(a == c) cout << b << endl;
    else if(b == c) cout << a << endl;
    else if(a == c && b == c) cout << 0 <<endl;
    else cout << a + b << endl;
    return 0;
}

附题目链接：洛谷P1601