用C++创建大整数类型 （1）创建一个更大的无符号长整型（精度可达1000位十进制） （2）创建该类型，都需要设计哪些内容？（存储表示，数据范围，运算，进位、输出） 设计完成100位大整数类的加、减、乘、除运算符重载。

（1）创建更大的无符号长整型

为了实现更大的无符号长整型，我们需要使用数组来存储这个数。每个元素都代表这个数的一位，因为最大的十进制数是9，所以每个元素只需要存储0~9之间的一个数字即可。

数据范围：最大可达1000位十进制数。

运算：我们需要实现加、减、乘、除等基本运算。

进位：在进行运算时，需要注意进位的问题。例如，在两个大整数相加时，如果某一位的和超过了9，我们就需要将进位的1加到下一位上。

输出：我们需要重载输出运算符，以便能够直接输出我们自己定义的大整数类型。

（2）设计100位大整数类的加、减、乘、除运算符重载

下面是一个简单的实现：

#include <iostream>
#include <string>
#include <cstring>

using namespace std;

class BigNum {
    public:
        BigNum() {
            memset(num, 0, sizeof(num));
            len = 1;
        }
        BigNum(const char *s) {
            memset(num, 0, sizeof(num));
            len = strlen(s);
            for (int i = 0; i < len; i++) {
                num[i] = s[len - i - 1] - '0';
            }
        }
        BigNum operator + (const BigNum &b) const {
            BigNum res;
            res.len = max(len, b.len);
            for (int i = 0; i < res.len; i++) {
                res.num[i] += num[i] + b.num[i];
                res.num[i+1] += res.num[i] / 10;
                res.num[i] %= 10;
            }
            if (res.num[res.len] > 0) {
                res.len++;
            }
            return res;
        }
        BigNum operator - (const BigNum &b) const {
            BigNum res;
            res.len = max(len, b.len);
            for (int i = 0; i < res.len; i++) {
                res.num[i] += num[i] - b.num[i];
                if (res.num[i] < 0) {
                    res.num[i] += 10;
                    res.num[i+1]--;
                }
            }
            while (res.len > 1 && res.num[res.len-1] == 0) {
                res.len--;
            }
            return res;
        }
        BigNum operator * (const BigNum &b) const {
            BigNum res;
            for (int i = 0; i < len; i++) {
                for (int j = 0; j < b.len; j++) {
                    res.num[i+j] += num[i] * b.num[j];
                    res.num[i+j+1] += res.num[i+j] / 10;
                    res.num[i+j] %= 10;
                }
            }
            res.len = len + b.len;
            while (res.len > 1 && res.num[res.len-1] == 0) {
                res.len--;
            }
            return res;
        }
        BigNum operator / (const BigNum &b) const {
            BigNum res;
            BigNum cur = 0;
            for (int i = len-1; i >= 0; i--) {
                cur = cur * 10 + num[i];
                int j;
                for (j = 0; j < 10; j++) {
                    if (cur < b * (j+1)) {
                        break;
                    }
                }
                res.num[i] = j;
                cur = cur - b * j;
            }
            res.len = len;
            while (res.len > 1 && res.num[res.len-1] == 0) {
                res.len--;
            }
            return res;
        }
        friend ostream& operator << (ostream &out, const BigNum &x) {
            for (int i = x.len-1; i >= 0; i--) {
                out << x.num[i];
            }
            return out;
        }
    private:
        int num[1005];
        int len;
};

int main() {
    BigNum a = "12345678901234567890";
    BigNum b = "98765432109876543210";

    cout << a + b << endl;
    cout << a - b << endl;
    cout << a * b << endl;
    cout << a / b << endl;

    return 0;
}

这里我们使用了一个私有变量num来存储大整数的每一位，以及一个公共变量len来记录大整数的长度。在构造函数中，我们将输入的字符串倒序存储到num数组中。在加、减、乘、除运算符重载中，我们都采用了类似于手算的方式来进行运算。当然，这只是一个简单的实现，针对特殊情况还需要进行优化。