uint8_t operations, when do they overflow?

Question

I'm not sure when I have to worry about overflows when using unsigned chars. This case is clear:

uint8_t a = 3;
uint8_t b = 6;
uint8_t c = a - b; // c is 253

However, what happens here:

float d = a - b; // d is -3

Are both a and be converted to float before doing the subtraction?

Or also in this case:

float e = (a - b) + (a - c);

Are all three variables converted to float?

Are there possible cases where an overflow can occur, even when the variable being assigned to is a float? Are the rules the same if e is a float, or int, or anything else?

Also, what happens in a case like this:

int a = std::abs(a - b);

unsigned operations never overflow, they just wrap around. `uint8_t c = a - b;` means `uint8_t c = (uint8_t)((int)a - (int)b);` which produces the wrapped result after the cast — phuclv, Aug 06 '15 at 12:30
TO add to @LưuVĩnhPhúc's comment, overflow is bad, very bad. It is undefined behavior. Unsigned integers never overflow. They instead use modulo 2^n arithmetic. — David Hammen, Aug 06 '15 at 12:35
Also see [Why must a short be converted to an int before arithmetic operations in C and C++?](http://stackoverflow.com/q/24371868/1708801) — Shafik Yaghmour, Aug 06 '15 at 13:02

score 9 · Accepted Answer · edited May 23 '17 at 11:51

Your case is not a result of char-to-float conversions, but is due to the integer promotion rules. Cppreference states the following (emphasis mine):

Prvalues of small integral types (such as char) may be converted to prvalues of larger integral types (such as int). In particular, arithmetic operators do not accept types smaller than int as arguments, and integral promotions are automatically applied after lvalue-to-rvalue conversion, if applicable. This conversion always preserves the value.

And:

unsigned char or unsigned short can be converted to int if it can hold its entire value range, and unsigned int otherwise.

So in your case, the - operator converts the values to integers, which are then converted to floats. Only the assignment to c converts back to a uint8_t (which overflows).

The same applies to the std::abs example: The values are converted before the subtraction, and the result in passed to the functions.

For more details on signed/unsigned promotions on arithmetic operations, see for example this answer: https://stackoverflow.com/a/6770275/3198247

uint8_t operations, when do they overflow?

1 Answers1