反向整数捕获溢出 C++

Question

您好，我正在尝试用 C++ 进行简单的反向整数运算。代码如下：

#include <iostream>
#include <algorithm>
#include <climits>

using namespace std;

class RevInteger {

public:
    int reverse(int x) 
    {
        int result = 0;
        bool isNeg = x > 0 ? false : true;
        x = abs(x);

        while (x != 0) 
        {
            result = result * 10 + x % 10;
            x = x / 10;
        }

        if (isNeg) 
            result *= -1;

        if (result > INT_MAX || result < INT_MIN)
            return 0;
        else
            return (int)result;
    }
};

当我输入 1534236469 时；我希望它 return me 0，而不是 return 给我一些垃圾值。我的程序有什么问题。另外，我正在尝试使用 climits 库，有没有更简单的方法来做同样的事情？

Answer 1

最简单的方法是使用 long long 代替结果 int，并在最后检查溢出：

long long result = 0;
/* the rest of your code */
return (int)result; // Now the cast is necessary; in your code you could do without it

另一种方法是将 int 转换为字符串，将其反转，然后使用标准库尝试将其转换回来，并在此过程中发现问题 (demo)：

int rev(int n) {
    auto s = to_string(n);
    reverse(s.begin(), s.end());
    try {
        return stoi(s);
    } catch (...) {
        return 0;
    }
}

如果必须保持在整数范围内，一种方法是在乘以 10 之前检查中间结果，并在相加后检查是否溢出：

while (x != 0) {
    if (result > INT_MAX/10) {
        return 0;
    }
    result = result * 10 + x % 10;
    if (result < 0) {
        return 0;
    }
    x = x / 10;
}

Answer 2

根据@daskblinkenlight 的建议；将结果更改为 long long 并在最后进行类型转换可以解决问题。

工作class：

class intReverse {

public:
int reverse(int x) {

    long long result = 0;  // only change here
    bool isNeg = x > 0 ? false : true;
    x = abs(x);
    while (x != 0) {
        result = result * 10 + x % 10;
        x = x / 10;
    }
    if (isNeg) {
        result *= -1;
    }
    if (result > INT_MAX || result < INT_MIN)
    {
        return 0;
    }
    else
    {
        return (int) result;
    }

  }
};

Answer 3

class Solution {
public:
    int reverse(int x) {
        int reversed = 0;

        while (x != 0) {
            if (reversed > INT_MAX / 10 || reversed < INT_MIN / 10) return 0;
            reversed = reversed * 10 + (x % 10);
            x /= 10;
        }        
        return reversed;
    }
};

如果reversed大于8位数字INT_MAX (INT_MAX / 10)，那么如果我们在reversed的基础上加1位数字，就会出现int溢出。类似于 INT_MIN.

Answer 4

int reverse(int x) {
        int pop = 0;
        int ans = 0;
        while(x) {
            // pop
            pop = x % 10;
            x /= 10;

            // check overflow
            if(ans > INT_MAX/10 || ans == INT_MAX/10 && pop > 7) return 0;
            if(ans < INT_MIN/10 || ans == INT_MIN/10 && pop < -8) return 0;

            // push
            ans = ans * 10 + pop;

        }
        return ans;
    }

反向整数捕获溢出 C++

Reverse Integer Catch overflow C++

c++

integer-overflow

c++11