How to check for INT_MAX without overflowing int - c++

Question

I created a BigInt class which allows for huge numbers (from any bases 2-36) far beyond the integer max by storing each digit in a vector. I need to be able to convert this back to an integer but return the int max/min instead if the max is reached, otherwise there will ofc be an integer overflow.
My question is how can I check if I have exceeded the max without overflowing the integer I am building. I have tried moving the if statements at the bottom into the for loop but my integer still overflows. I feel like the solution is simple but I just can't grasp it.
// Convert BigInt to integer base 10 and return that int
// If BigInt > INT_MAX, return INT_MAX.
// If BigInt < INT_MIN, return INT_MIN.
int BigInt::to_int() const{
int number = 0;
for(size_t i = 0; i < vec.size(); i++) {
number += vec[i] * pow(base, i);
}
if (!isPositive) { number *= -1; }
if (number > INT_MAX) { return INT_MAX; }
if (number < INT_MIN) { return INT_MIN; }
return number;
}

Answer 1

Comparing an int value to INT_MAX is pointless except for equality because all values are less than or equal.
Performing overflow check after the overflowing signed operations is pointless because either they show that there was no overflow or the behaviour of the program is undefined. Always do the check before attempting operations that would overflow the result.
In this case, convert INT_MAX to your BigInt type and compare that with *this.

Answer 2

Preliminary info: you need to check for overflow before calculating something that overflows. If the overflow already happened, it's too late.
Adding an overflow check to your version of to_int() is tricky because you build up your value starting from the one's place. Because of this approach, you try to add pow(base, i), which could overflow an int by itself and that is not easy to detect in advance. Possible, but let's consider something else.
If you were to build up your value ending at the one's place (i.e. repeatedly calculate number*base + digit), you could check for overflow before multiplying. Here is some math, using shorter names for an easier read. Let x and M be integers, base a positive integer, and d some non-negative integer less than base. (M short for "max" and d short for "digit".) Division will mean real-valued division, as I can trunc() the result to get integer division. We want to know how x*base + d compares to M.
If x*base + d <= M then dividing by base gives x + d/base <= M/base, hence x <= trunc(M/base).
By the contrapositive, if x > trunc(M/base) then x*base + d > M.
If x*base + d >= M then dividing by base gives x + d/base >= M/base, hence x >= trunc(M/base).
By the contrapositive, if x < trunc(M/base) then x*base + d < M.
If x == trunc(M/base) then x*base == trunc(M/base)*base. Add M%base to both sides to get x*base + M%base == M. Well, I hope you'll accept the observation that trunc(M/base)*base + M%base == M. If you can accept that much, then the comparison between x*base + d and M is the same as the comparison between d and M%base.
Done with the math. Let's put this into code. You might note a performance increase as well, depending on how your compiler optimizes.
// Tests if number * base + next_digit will overflow an int.
bool will_overflow(int number, int base, int next_digit )
{
if ( number > INT_MAX/base )
return true;
if ( number < INT_MAX/base )
return false;
// It's close enough that the next digit decides it.
return next_digit > INT_MAX % base;
}
// Convert BigInt to integer base 10 and return that int
// If BigInt > INT_MAX, return INT_MAX.
// If BigInt < INT_MIN, return INT_MIN.
int BigInt::to_int() const {
int number = 0;
// Loop in the reverse direction. Be careful with unsigned values!
for(size_t i = vec.size(); i > 0; --i) {
if ( will_overflow(number, base, vec[i-1]) )
return isPositive ? INT_MAX : INT_MIN;
number = number * base + vec[i-1];
}
return number;
}
I will point out one small cheat in this. There is a single negative value that fits in an int, but whose absolute value is greater than INT_MAX. If that singular value comes up, this function will incorrectly detect it as an overflow and return INT_MIN. Fortunately, that works out fine since the singular value is INT_MIN. :)