编译器项目需求：超int_64范围的字符串数字转int_64并溢出为负数

首先明确int64_t的范围：最大值是9223372036854775807，最小值是-9223372036854775808。当数值超过最大值时，按照补码溢出规则，最大值+1会直接变成最小值，这正是你编译器项目需要的行为。下面提供两种实用的实现方式：

方法一：利用__int128中转（简单高效） #

大部分主流编译器（比如GCC、Clang）都支持__int128这种128位整数类型，它的范围足够容纳超出int64_t的数值。我们可以先把字符串转成__int128，再强制转换为int64_t，利用整数溢出特性自动得到目标值：

#include <iostream>
#include <string>

int64_t str_to_int64_with_overflow(const std::string& s) {
    __int128 val = 0;
    bool is_negative = false;
    size_t idx = 0;

    // 处理符号位
    if (s[idx] == '-') {
        is_negative = true;
        idx++;
    } else if (s[idx] == '+') {
        idx++;
    }

    // 逐位解析字符串
    for (; idx < s.size(); ++idx) {
        val = val * 10 + (s[idx] - '0');
    }

    if (is_negative) {
        val = -val;
    }

    // 强制转换触发溢出，自动符合补码规则
    return static_cast<int64_t>(val);
}

int main() {
    std::string s = "9223372036854775808";
    int64_t result = str_to_int64_with_overflow(s);
    std::cout << result << std::endl; // 输出：-9223372036854775808
    return 0;
}

这种方法的优势是代码简洁，不需要手动处理溢出逻辑——虽然C++标准中有符号整数溢出是未定义行为，但在绝大多数编译器中都会按照补码规则处理，对于编译器项目来说，完全可以依赖这种行为来实现需求。

方法二：手动模拟补码溢出（不依赖__int128） #

如果你的编译器不支持__int128，可以手动逐位处理字符串，同时检查溢出情况，手动模拟补码的溢出行为：

#include <iostream>
#include <string>
#include <limits>

int64_t str_to_int64_with_overflow(const std::string& s) {
    int64_t val = 0;
    bool is_negative = false;
    size_t idx = 0;

    // 处理符号
    if (s[idx] == '-') {
        is_negative = true;
        idx++;
    } else if (s[idx] == '+') {
        idx++;
    }

    const int64_t max_val = std::numeric_limits<int64_t>::max(); // 9223372036854775807
    const int64_t min_val = std::numeric_limits<int64_t>::min(); // -9223372036854775808

    for (; idx < s.size(); ++idx) {
        int digit = s[idx] - '0';

        if (!is_negative) {
            // 检查正数溢出：当前值超过max_val/10，或者等于max_val/10但当前 digit 超过max_val的最后一位
            if (val > max_val / 10 || (val == max_val / 10 && digit > max_val % 10)) {
                val = min_val; // 溢出后直接跳到最小值
                break; // 剩余字符无需处理
            }
            val = val * 10 + digit;
        } else {
            // 检查负数溢出：当前值小于min_val/10，或者等于min_val/10但当前 digit 超过min_val最后一位的绝对值
            if (val < min_val / 10 || (val == min_val / 10 && digit > -(min_val % 10))) {
                val = max_val; // 溢出后跳到最大值
                break;
            }
            val = val * 10 - digit;
        }
    }

    return val;
}

int main() {
    std::string s = "9223372036854775808";
    int64_t result = str_to_int64_with_overflow(s);
    std::cout << result << std::endl; // 输出：-9223372036854775808
    return 0;
}

这种方法完全手动处理每一步的溢出判断，不需要依赖额外的大整数类型，兼容性更好。需要注意的是，min_val的绝对值比max_val大1，所以负数的溢出判断逻辑和正数略有区别。

额外说明 #

• 正数溢出：数值超过int64_t最大值时，结果会绕回最小值（max_val +1 = min_val）
• 负数溢出：数值小于int64_t最小值时，结果会绕回最大值（min_val -1 = max_val），上面的方法二已经覆盖了这种情况的处理

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