【运算符重载】类型转换运算符

#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
using namespace std;
const int MAX = 110;
class CHugeInt
{
public:
    int arr[MAX]{0};
    int len;
    CHugeInt(int n)
    {
        arr[0] = n % 1000000000;
        arr[1] = n / 1000000000;
        len = (arr[1] == 0) ? 1 : 2;
    }
    CHugeInt(const char *s)
    {
        len = strlen(s) / 9 + 1;               // 一个int元素最多存9位，因为int是10位，防止溢出
        const char *p = s + strlen(s) - 1 - 8; // 指向最低9位中的最高位
        int i = 0;
        // 把高位数存在数组的后面，如果出现高位进位，方便处理
        for (; p >= s; ++i, p -= 9) // 先读低位，再读高位
        {
            const char *pp = p; // 用pp读取接下来的9位
            for (int j = 0; (j < 9); ++j, ++pp)
            {
                arr[i] = arr[i] * 10 + (*pp - '0'); // 逐位将字符串读入int数组
            }
        }
        if (p + 9 != s) // 如果高位还没读取完
        {
            int rest = p + 9 - s;
            p = s;
            for (int j = 0; j < rest; ++j, ++p)
                arr[i] = arr[i] * 10 + (*p - '0');
        }
    }
    CHugeInt(const CHugeInt &hi)
    {
        memcpy(arr, hi.arr, hi.len * sizeof(int));
        len = hi.len;
    }
    CHugeInt operator+(const CHugeInt &hi) // 把右边的加到左边上
    {
        int i = 0;
        CHugeInt tmp(*this);
        int c = 0; // 低位进位
        do
        {
            int sum = tmp.arr[i] + hi.arr[i] + c;
            c = sum / 1000000000;
            tmp.arr[i] = sum % 1000000000;
            ++i;
        } while ((i <= hi.len) && (i <= tmp.len));
        return tmp;
    }
    CHugeInt operator+(int n) // 把右边的加到左边上
    {
        CHugeInt tmp(*this);
        int sum = tmp.arr[0] + n;
        int c = sum / 1000000000;
        tmp.arr[1] += c;
        tmp.arr[0] = sum % 1000000000;
        return tmp;
    }
    void operator+=(int n)
    {
        int sum = arr[0] + n;
        int c = sum / 1000000000;
        arr[1] += c;
        arr[0] = sum % 1000000000;
    }
    CHugeInt &operator++()
    {
        int sum = arr[0] + 1;
        if (sum == 1000000000)
        {
            arr[0] = 0;
            arr[1] += 1;
        }
        else
        {
            arr[0] = sum;
        }
        return *this;
    }
    CHugeInt operator++(int)
    {
        CHugeInt tmp(*this);
        int sum = arr[0] + 1;
        if (sum == 1000000000)
        {
            arr[0] = 0;
            arr[1] += 1;
        }
        else
        {
            arr[0] = sum;
        }
        return tmp;
    }
    friend CHugeInt operator+(int n, const CHugeInt &hi)
    {
        CHugeInt tmp(hi);
        int sum = tmp.arr[0] + n;
        int c = sum / 1000000000;
        tmp.arr[1] += c;
        tmp.arr[0] = sum % 1000000000;
        return tmp;
    }
    friend ostream &operator<<(ostream &os, const CHugeInt &hi)
    {
        int i = hi.len;
        while (i--)
        {
            os << hi.arr[i];
        }
        return os;
    }
};
int main()
{
    char s[210];
    int n;
    while (cin >> s >> n)
    {
        CHugeInt a(s);
        CHugeInt b(n);
        cout << a + b << endl; // 重载“+”和"<<"运算符
        cout << n + a << endl; // 这里需要重载operator+(int, CHugeInt()),
        cout << a + n << endl; // 不能重载int()类型转换运算符
        b += n;                // 重载“+=”运算符
        cout << ++b << endl;   // 重载前置“++”运算符
        cout << b++ << endl;   // 重载后置“++”运算符
    }
    return 0;
}

• 考察各种运算符的重载
• 读取一个大数的时候，要从低位开始读，不能从高位开始读（血的教训。。。）