how does comparison operator works in case of overflow

Question

i have the following code :

int main() {
   int64_t val1 = 0x8000000000000000;
   int64_t val2 = 0x1c11223344556677;
   if(val1 > val2) {
      std::cout << "Val1 is greater than val2"<< std::endl;
   }
   else {
      std::cout << "Val2 is greater than val1"<< std::endl;
   }
   return 0;
}

The get the print for else part of the code.

i wanted to know how does comparison operator or for that matter any arithmetic operation work in case one of the value exceeds the max value ?

score 4 · Answer 1 · answered Apr 11 '14 at 09:20

4

According to C++11 §5:

If during the evaluation of an expression, the result is not mathematically defined or not in the range of representable values for its type, the behavior is undefined.

answered Apr 11 '14 at 09:20

herohuyongtao

49,413
29
133
174

There is no "evaluation of an expression" here. These two integers are defined by giving their hexadecimal value directly. – kol Apr 11 '14 at 09:32
@kol Here, `int64_t val1 = ...` are the evaluation expressions. :P – herohuyongtao Apr 11 '14 at 09:41

score 4 · Answer 2 · answered Apr 11 '14 at 10:34

The value 0x8000000000000000 is a large unsigned integer, 9223372036854775808 as a decimal.

The maximum value that can be stored in a 64-bit signed integer, represented by INT_64_MAX or similar, is 9223372036854775807.

The conversion of this value from unsigned to signed is covered in the standard at n3797 S4.7/3:

If the destination type is signed, the value is unchanged if it can be represented in the destination type (and bit-field width); otherwise, the value is implementation-defined.

Since it cannot be so represented, the behaviour is implementation-defined.

What will actually happen on most implementations is that the bit value will be stored unchanged. Now val1 has a value that is outside the allowable range, and any use of it will result in Undefined Behaviour.

In particular the comparison between two signed integers, one of which is outside the allowable range, cannot be reliably predicted. It will probably defer to a specific instruction in the underlying machine hardware, so you would have to inspect the generated code to determine which that would be. I can write the code and tell you what I find, but for a different compiler or different processor it might be different.

Best advice is always to avoid Undefined Behaviour if you possibly can.

I'd argue that the comparison has nothing wrong. By the time the comparison occurs, the implementation-defined behaviour in the initialization of `val1` has already occurred (and has put it into a value that is in the allowable range for an `int64_t`). So by the time `if (val1 > val2)` is executed `val1` value is implementation-defined, thus by extension the result of the comparison will also be implementation-defined. — Andre Kostur, Apr 11 '14 at 13:53
@AndreKostur: (a) the standard does not define 'wrong' (b) in most implementations the assignment will __not__ put a valid signed integer value into val1 (c) comparison to an out of range value is UB. You can easily test (b) if you like by round-tripping from unsigned to int to unsigned. — david.pfx, Apr 11 '14 at 14:08

kol · Answer 3 · 2014-04-11T09:29:58.177

The comparison operator works as usual: in this case, val1 will be negative (its most significant bit is set!), so it will be less than val2, which is positive.

#include <iostream>

int main() {
   int64_t val1 = 0x8000000000000000;
   int64_t val2 = 0x1c11223344556677;
   std::cout << "val1: " << val1 << std::endl;
   std::cout << "val2: " << val2 << std::endl;
   if(val1 > val2) {
      std::cout << "Val1 is greater than val2"<< std::endl;
   }
   else {
      std::cout << "Val2 is greater than val1"<< std::endl;
   }
   return 0;
}

Output (ideone):

val1: -9223372036854775808
val2: 2022435311251187319
Val2 is greater than val1

score 1 · Answer 4 · edited May 23 '17 at 10:26

1

In else I hope you mean greater than or equal to.

Opertor simply won't work as int64_t is meant to store values in limit (-2^63 to 2^63-1). If you want more range use unsigned version. For even more range use some readily available bignum library or write one by yourself. (For example you can store large numbers in string and comparision would become extremely easy)

edited May 23 '17 at 10:26

Community

1
1

answered Apr 11 '14 at 09:20

Mohit Jain

30,259
8
73
100

how does comparison operator works in case of overflow

4 Answers4