Learning C++, day three: Integer overflow

I was happily playing with my shiny new prime-number-checker, trying out how loops work in C++.

When I started entering stupidly big numbers, something strange happened.

./main
Enter a number: 5784320578432578493207508493
Congratulations, it's prime!

Except, that is not actually a prime number. I can’t have typed a prime number by randomly banging on the keypad. What’s going on?

I didn’t code any input sanitization in my prime-number-checker, so let’s check what my program actually gets. I am now removing all the boring logic, and compiling this simple code:

// Main.cpp

#include <iostream>
using std::cin;
using std::cout;
using std::endl;

int main()
{
	int x;

	cout << "Enter a number: ";
	cin >> x;

	cout << "You entered " << x << endl;

	return 0;
}

Let’s play.

./main
Enter a number: 2147483647 <-- int32 maximum positive value
You entered 2147483647

./main
Enter a number: 2147483648 <-- int32 maximum positive value +1
You entered 2147483647

./main
Enter a number: 99999999999999999999999999999999999999999999999999 <-- a lot
You entered 2147483647

With this, the first mystery is solved: I was always checking the same value, no matter what big number I was entering. And it happened to be prime (yes: (2^32)/2-1 is indeed prime!).

But now I have another problem: why do I always get the same number? The variable x is a 32-bit integer and it can’t hold those big numbers. But still, I was expecting the integer overflow to wrap around the maximum value.

For example: 2147483647 is the maximum value for a signed 32-bit integer. I expected the input 2147483648 to be stored in x as the smallest possible value: -2147483648.

Instead, I get 2147483647 every time.

Let’s try something different.

./main
Enter a number: I am not a number, I am a free man!
You entered 0

Woops. OK there’s some magic going on here, and it is not about integer representation. It’s std::cin doing the magic!

We need some differential diagnosis. I am now removing std::cin and hardcoding the values.

// Main.cpp

#include <iostream>
using std::cout;
using std::endl;

int main()
{
	// By the way: "int" has its constructor overloaded, too!
	int x(2147483647);

	cout << "2147483647   = " << x << endl;

	x = x + 1;
	cout << "2147483647+1 = " << x << endl;

	return 0;
}

./main
2147483647   = 2147483647
2147483647+1 = -2147483648

OK, that’s better! Finally, a good old wrapping integer overflow.