高精度整数加法

#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <cstdlib>
#include <algorithm>

using namespace std;

class InfiniteInt {
public:
    // 默认构造函数
    InfiniteInt() : digits(0) {}

    // 将十进制字符串转换为无限长整数
    InfiniteInt(const string& str) {
        // 计算需要多少个 byte：
        // 根据十进制位数 d，最大数为 10^d - 1，
        // 需要的二进制位数至少为 ceil(d * log2(10))，
        // 转换成 byte 数量即为 (bits/8) + 1（这里使用整除，保证足够存储）
        double d = static_cast<double>(str.length());
        this->digits = (static_cast<int64_t>(std::ceil(d * std::log2(10))) / 8) + 1;
        
        // 分配内存，每个 byte 用 malloc(1) 得到一个 char*，初值设为 0
        for (int32_t i = 0; i < this->digits; i++) {
            char* byte = reinterpret_cast<char*>(malloc(1));
            *byte = 0;
            numbers.push_back(byte);
        }
        
        // 从字符串中转换，每次乘以 10，再加上当前数字
        // 这里采用的是“高位先”的处理：依次处理字符串中的每个字符
        for (char ch : str) {
            int digitVal = ch - '0';
            
            // 先将当前数乘以 10
            int carry = 0;
            for (int i = 0; i < this->digits; i++) {
                int tmp = (static_cast<unsigned char>(*numbers[i]) * 10) + carry;
                *numbers[i] = tmp & 0xFF;
                carry = tmp >> 8;  // 除以 256 的商作为进位
            }
            // 然后加上当前的数字
            carry = digitVal;
            for (int i = 0; i < this->digits; i++) {
                int tmp = static_cast<unsigned char>(*numbers[i]) + carry;
                *numbers[i] = tmp & 0xFF;
                carry = tmp >> 8;
            }
        }
    }
    
    // 析构函数：释放内部申请的内存
    ~InfiniteInt() {
        for (char* byte : numbers) {
            free(byte);
        }
    }
    
    // 加法运算：返回一个新的 InfiniteInt 对象（this + other）
    InfiniteInt operator+(const InfiniteInt& other) const {
        // 取较大的字节数，再加一位可能的进位
        int64_t maxDigits = std::max(this->digits, other.digits);
        InfiniteInt result;
        result.digits = maxDigits + 1;
        for (int i = 0; i < result.digits; i++) {
            char* byte = reinterpret_cast<char*>(malloc(1));
            *byte = 0;
            result.numbers.push_back(byte);
        }
        
        int carry = 0;
        // 按低位到高位依次相加
        for (int i = 0; i < result.digits; i++) {
            int a = (i < this->digits) ? static_cast<unsigned char>(*this->numbers[i]) : 0;
            int b = (i < other.digits) ? static_cast<unsigned char>(*other.numbers[i]) : 0;
            int sum = a + b + carry;
            *result.numbers[i] = sum & 0xFF;
            carry = sum >> 8;
        }
        
        // 如果最高字节为 0，则可以减少一位（但 0 本身应保留至少 1 个 byte）
        if (result.digits > 1 && static_cast<unsigned char>(*result.numbers[result.digits - 1]) == 0) {
            free(result.numbers[result.digits - 1]);
            result.numbers.pop_back();
            result.digits--;
        }
        
        return result;
    }
    
    // 输出运算符重载，将 InfiniteInt 转换为十进制字符串输出
    friend ostream& operator<<(ostream& os, const InfiniteInt& num) {
        // 将内部表示（little-endian）转换为 big-endian 存储到一个 vector 中
        vector<int> temp;
        for (int i = num.digits - 1; i >= 0; i--) {
            temp.push_back(static_cast<unsigned char>(*num.numbers[i]));
        }
        
        // 特殊情况：数值为 0
        if (temp.size() == 0 || (temp.size() == 1 && temp[0] == 0)) {
            os << "0";
            return os;
        }
        
        string result;
        // 使用长除法算法：不断除以 10，记录余数
        while (!(temp.size() == 1 && temp[0] == 0)) {
            int remainder = 0;
            for (size_t i = 0; i < temp.size(); i++) {
                int current = remainder * 256 + temp[i];
                int quotient = current / 10;
                remainder = current % 10;
                temp[i] = quotient;
            }
            result.push_back('0' + remainder);
            // 去掉前导零
            while (temp.size() > 1 && temp[0] == 0) {
                temp.erase(temp.begin());
            }
        }
        // 余数记录的是低位在前，需要反转得到正确顺序
        reverse(result.begin(), result.end());
        os << result;
        return os;
    }
    
private:
    int64_t digits;           // 内部用多少个 byte 存储
    vector<char*> numbers;    // 存储各个字节，索引 0 为最低有效字节
};

print(sum(map(int, [input(), input()])))