integer-overflow

I have come across the below C++ program ( source ): #include <iostream> int main() { for (int i = 0; i < 300; i++) std::cout << i << " " << i * 12345678 << std::endl; } It looks like a simple program and gives the correct output on my local machine i.e. something like: 0 0 1 12345678 2 24691356 ... 297 -628300930 298 -615955252 299 -603609574 But, on online IDEs like codechef , it gives the following output: 0 0 1 12345678 2 24691356 ... 4167 -95167326 4168 -82821648 4169 -7047597 Why doesn't the for loop terminate at 300? Also this program always terminates on 4169 . Why 4169 and not some

Is there a general way to check for an overflow or an underflow of a given data type (uint32, int etc.)? I am doing something like this: uint32 a,b,c; ... //initialize a,b,c if(b < c) { a -= (c - b) } When I print a after some iterations, it displays a large number like: 4294963846. To check for over/underflow in arithmetic check the result compared to the original values. uint32 a,b; //assign values uint32 result = a + b; if (result < a) { //Overflow } For your specific the check would be: if (a > (c-b)) { //Underflow } I guess if I wanted to do that I would make a class that simulates the

I'm working on a verification-tool for some VHDL-Code in MATLAB/Octave. Therefore I need data types which generate "real" overflows: intmax('int32') + 1 ans = -2147483648 Later on, it would be helpful if I can define the bit width of a variable, but that is not so important right now. When I build a C-like example, where a variable gets increased until it's smaller than zero, it spins forever and ever: test = int32(2^30); while (test > 0) test = test + int32(1); end Another approach I tried was a custom "overflow"-routine which was called every time after a number is changed. This approach was

What will the unsigned int contain when I overflow it? To be specific, I want to do a multiplication with two unsigned int s: what will be in the unsigned int after the multiplication is finished? unsigned int someint = 253473829*13482018273; unsigned numbers can't overflow, but instead wrap around using the properties of modulo. For instance, when unsigned int is 32 bits, the result would be: (a * b) mod 2^32 . As CharlesBailey pointed out, 253473829*13482018273 may use signed multiplication before being converted, and so you should be explicit about unsigned before the multiplication: