image.png

    1. #include <iostream>
    2. #include <cstring>
    3. #include <cstdlib>
    4. #include <cstdio>
    5. using namespace std;
    6. const int MAX = 110;
    7. class CHugeInt
    8. {
    9. public:
    10.     int arr[MAX]{0};
    11.     int len;
    12.     CHugeInt(int n)
    13.     {
    14.         arr[0] = n;
    15.         len = 1;
    16.     }
    17.     CHugeInt(const char *s)
    18.     {
    19.         len = strlen(s) / 9 + 1; // 一个int元素最多存9位，因为int是10位，防止溢出
    20.         const char *p = s;       // 指向第一个数字
    21.         int i = len;
    22.         // 把高位数存在数组的后面，如果出现高位进位，方便处理
    23.         while (i--)
    24.         {
    25.             for (int j = 0; j < 9 && *p != '\0'; ++j, ++p)
    26.             {
    27.                 arr[i] = arr[i] * 10 + (*p - '0'); // 逐位将字符串读入int数组
    28.             }
    29.         }
    30.     }
    31.     CHugeInt(const CHugeInt &hi)
    32.     {
    33.         memcpy(arr, hi.arr, hi.len * sizeof(int));
    34.         len = hi.len;
    35.     }
    36.     CHugeInt operator+(const CHugeInt &hi) // 把右边的加到左边上
    37.     {
    38.         int i = 0;
    39.         CHugeInt tmp(*this);
    40.         int c = 0; // 低位进位
    41.         do
    42.         {
    43.             int sum = tmp.arr[i] + hi.arr[i] + c;
    44.             c = sum / 1000000000;
    45.             tmp.arr[i] = sum % 1000000000;
    46.             ++i;
    47.         } while ((i <= hi.len) && (i <= tmp.len));
    49.         return tmp;
    50.     }
    51.     void operator+=(int n)
    52.     {
    53.         int sum = arr[0] + n;
    54.         int c = sum / 1000000000;
    55.         arr[1] += c;
    56.         arr[0] = sum % 1000000000;
    57.     }
    58.     CHugeInt &operator++()
    59.     {
    60.         int sum = arr[0] + 1;
    61.         if (sum == 1000000000)
    62.         {
    63.             arr[0] = 0;
    64.             arr[1] += 1;
    65.         }
    66.         else
    67.         {
    68.             arr[0] = sum;
    69.         }
    70.         return *this;
    71.     }
    72.     CHugeInt operator++(int)
    73.     {
    74.         CHugeInt tmp(*this);
    75.         int sum = arr[0] + 1;
    76.         if (sum == 1000000000)
    77.         {
    78.             arr[0] = 0;
    79.             arr[1] += 1;
    80.         }
    81.         else
    82.         {
    83.             arr[0] = sum;
    84.         }
    85.         return tmp;
    86.     }
    87.     friend ostream &operator<<(ostream &os, const CHugeInt &hi)
    88.     {
    89.         int i = hi.len;
    90.         while (i--)
    91.         {
    92.             os << hi.arr[i];
    93.         }
    94.         return os;
    95.     }
    96. };
    97. CHugeInt operator+(int n, const CHugeInt &hi)
    98. {
    99.     CHugeInt tmp(hi);
    100.     int sum = tmp.arr[0] + n;
    101.     int c = sum / 1000000000;
    102.     tmp.arr[1] += c;
    103.     tmp.arr[0] = sum % 1000000000;
    105.     return tmp;
    106. }
    107. int main()
    108. {
    109.     char s[210];
    110.     int n;
    112.     while (cin >> s >> n)
    113.     {
    114.         CHugeInt a(s);
    115.         CHugeInt b(n);
    116.         cout << a + b << endl;
    117.         cout << n + a << endl;
    118.         cout << a + n << endl;
    119.         b += n;
    120.         cout << ++b << endl;
    121.         cout << b++ << endl;
    122.         cout << b << endl;
    123.     }
    124.     return 0;
    125. }
    • 考察各种运算符的重载，“+”、自增运算符、流输出运算符。需要注意以下几点：
      1. memcpy()函数最后一个参数是拷贝的字节数，所以一般用n * sizeof()作为该参数的实参
      2. 前置“++”要返回自己引用，后置“++”别忘了自己加完了，返回加之前的自己的临时对象
      3. “+=”运算符也是需要重载的