自定义无符号大整数类减法模运算结果异常排查

核心问题拆解 #

你的情况有两个关键矛盾点：

• get()函数处理超过24位的数值时输出异常，但明明没写类型转换运算符，主程序里隐式转成unsigned long long的结果却完全正确——这肯定是编译器触发了你没注意到的隐式转换路径（比如类里有单参数构造函数被反向利用，或者你误以为是隐式转换，实际是调用了get()却没写括号）。
• 超过24位后get()出错，24位以内正常，说明get()对uint8_t[]数组的数值拼接逻辑有边界错误，刚好卡在3个字节的位置。

具体排查&修复步骤 #

1. 先搞清楚隐式转换的真实原因 #

既然你没声明operator unsigned long long()，但主程序能隐式转，先查这两点：

• 类里有没有UnsignedBigInteger(unsigned long long val)这种单参数构造函数？C++里如果没加explicit，编译器会反向用它把对象转成unsigned long long，这是旧特性，很容易被忽略。
• 是不是主程序里的代码其实是unsigned long long x = obj.get();，但你漏看了get()调用，误以为是隐式转换？

2. 修复get()的数值拼接逻辑 #

24位刚好是3个uint8_t字节，超过就炸，大概率是这几个常见错误：

错误1：字节顺序搞反了

如果你的uint8_t[]是小端存储（低位字节存在数组低索引），但拼接时按大端顺序算，超过24位后高位字节全错。比如：

// 错误示例：小端存储却按大端拼接
unsigned long long UnsignedBigInteger::get() const {
    unsigned long long res = 0;
    for (int i = 0; i < m_size; ++i) {
        res = (res << 8) | m_data[i]; // 小端应该从后往前遍历
    }
    return res;
}

修复：小端存储就反向遍历数组：

unsigned long long UnsignedBigInteger::get() const {
    unsigned long long res = 0;
    for (int i = m_size - 1; i >= 0; --i) {
        res = (res << 8) | m_data[i];
    }
    return res;
}

如果是大端存储，就保持正向遍历，但要注意数组长度别超过8（毕竟unsigned long long是64位）。

错误2：循环硬编码了3个字节

比如get()里写死只处理前3个字节，超过24位直接截断后面的：

// 错误示例：固定只处理3个字节
unsigned long long UnsignedBigInteger::get() const {
    unsigned long long res = 0;
    for (int i = 0; i < 3; ++i) { // 硬编码3，超过就忽略后续字节
        res |= (static_cast<unsigned long long>(m_data[i]) << (i * 8));
    }
    return res;
}

修复：用数组实际长度做循环边界，同时限制不超过8字节（unsigned long long的最大长度）：

unsigned long long UnsignedBigInteger::get() const {
    unsigned long long res = 0;
    const int max_bytes = sizeof(unsigned long long);
    int bytes_to_process = std::min(m_size, max_bytes);
    for (int i = 0; i < bytes_to_process; ++i) {
        // 小端存储的移位方式，大端就改移位方向
        res |= (static_cast<unsigned long long>(m_data[i]) << (i * 8));
    }
    return res;
}

错误3：operator-的借位处理没遍历全数组

如果operator-在处理a < b的模运算时，只处理了前3个字节的借位，后面的字节没管，导致数组存储值错误，但隐式转换刚好只取低64位（刚好是对的模运算结果），而get()读了全数组就错了。比如：

// 错误示例：借位只处理前3个字节
UnsignedBigInteger UnsignedBigInteger::operator-(const UnsignedBigInteger& rhs) const {
    UnsignedBigInteger res = *this;
    bool borrow = false;
    for (int i = 0; i < 3; ++i) { // 只处理前3个字节，借位没传下去
        uint8_t sub = res.m_data[i] - rhs.m_data[i] - borrow;
        borrow = (res.m_data[i] < rhs.m_data[i] + borrow);
        res.m_data[i] = sub;
    }
    return res;
}

修复：遍历整个数组处理借位，直到借位清零：

UnsignedBigInteger UnsignedBigInteger::operator-(const UnsignedBigInteger& rhs) const {
    UnsignedBigInteger res = *this;
    bool borrow = false;
    int max_len = std::max(m_size, rhs.m_size);
    for (int i = 0; i < max_len; ++i) {
        uint8_t a = (i < m_size) ? m_data[i] : 0;
        uint8_t b = (i < rhs.m_size) ? rhs.m_data[i] : 0;
        uint8_t sub = a - b - borrow;
        borrow = (a < b + borrow);
        res.m_data[i] = sub;
    }
    // 无符号数减法本身就是模运算，最后借位自动忽略
    return res;
}

3. 调试小技巧 #

• 直接打印uint8_t[]的每个字节值，手动算一遍数值，和get()的输出对比，一眼就能看出是字节顺序错了还是循环少了。
• 给单参数构造函数加explicit，阻止意外的隐式转换，这样主程序里必须显式调用get()，方便你定位问题。

内容的提问来源于stack exchange，提问作者Giogre