如何控制从 long 到 int 的隐式转换？

Question

I am working on this LeetCode problem to take an integer and reverse it, given that the reversed in is within the signed 32-bit range, in which case we should return 0.

and this code is doing just that, even with numbers like 1534236469/-1534236469. Except when it comes to tricky numbers like -2147483648 where its not recognising it as out of range and instead returning 8 and not 0.

I know this is not the cleanest code, but can you help me recognise what I'm missing?

#include<iostream>
#include<limits>
using namespace std;

class Solution {
public:
    int reverse(int x) {
        int a, r, y;
        string num, fnum;
        a = abs(x);
        try{
            while(a != 0){
                r = a % 10;
                a = a / 10;
                num = to_string(r);
                fnum = fnum + num;
                y = stoi(fnum);
            }
        } catch(out_of_range& oor){
            return 0;
        }
        if(x==0){
            return 0;
        } else if (x<0){
            return -y;
        } else {
            return y;
        }
    }
};

int main(){
    Solution mine;
    cout << mine.reverse(-2147483648);
}

Answer 1

[...] when it comes to tricky numbers like -2147483648 where its not recognising it as out of range and instead returning 8 and not 0.

That number is "tricky" because it's equal to std::numeric_limits<int>::min() in your environment and given a two's complement representation of type int , it happens that std::abs(-2147483648) == -2147483648 .

Next in your (contrived, I must say, there's no need to use a string here) code, the line num = to_string(r); would result in num = "-8" , so that the loop would compose a string like "-8-4-6-3-8-4-7-4-1-2" .

When applyed to strings like that, stoi doesn't throw an exception, it just stops parsing (you would have noticed it by passing and inspecting its other parameters).

If you want to check if the result is outside the range of an int , you could use locally a wider type (eg long long ) and check the boundaries after the calculations or keep using int , but compare all the intermediate values with the limits before any calculation.