Question

Suppose I have these two types:

typedef unsigned long long uint64;
typedef signed long long sint64;

And I have these variables:

uint64 a = ...;
uint64 b = ...;
sint64 c;

I want to subtract b from a and assign the result to c, clearly if the absolute value of the difference is greater than 2^63 than it will wrap (or be undefined) which is ok. But for cases where the absolute difference is less than 2^63 I want the result to be correct.

Of the following three ways:

c = a - b; // sign conversion warning ignored

c = sint64(a - b);

c = sint64(a) - sint64(b);

Which of the them are guaranteed to work by the standard? (and why/how?)

Answer 1

None of the three work. The first fails if the difference is negative (no matter the absolute value), the second is the same as the first, and the third fails if either operand is too large.

It’s impossible to implement without a branch.

c = b < a? a - b : - static_cast< sint64 >( b - a );

Fundamentally, unsigned types use modulo arithmetic without any kind of sign bit. They don’t know they wrapped around, and the language spec doesn’t identify wraparound with negative numbers. Also, assigning a value outside the range of a signed integral variable results in an implementation-defined, potentially nonsense result (integral overflow).

Consider a machine with no hardware to convert between native negative integers and two’s complement. It can perform two’s complement subtraction using bitwise negation and native two’s complement addition, though. (Bizarre, maybe, but that is what C and C++ currently require.) The language leaves it up to the programmer, then, to convert the negative values. The only way to do that is to negate a positive value, which requires that the computed difference be positive. So…

The best solution is to avoid any attempt to represent a negative number as a large positive number in the first place.

EDIT: I forgot the cast before, which would have produced a large unsigned value, equivalently to the other solutions!