Is there a difference between unary - and n -

Question

I am fairly certain that subtracting one uint8_t from another should result in another unsigned number, but some of my results are confusing me.

  uint8_t a = 2;
  uint8_t b = 1;
  uint8_t c = -a;
  long d = b - a;
  long e = b + c;

When I obtain the value of d it produces -1, while e is as I would expect 255. This is a bug with the version of gcc I am using.....right?

For reference I am using the arm-none-eabi-g++ compiler for my MSP-432.

Looking at this seems to indicate that gcc just seems to make the same mistake here.

Looking at this SO question it seems that godbolt and the arm gcc is wrong.

What is going on here?

In C you cannot operate on types smaller than `int`. Search for implicit conversions. — too honest for this site, Jan 13 '17 at 16:59
Integer promotions as part of arithmetic conversions. The upshot is that you cannot use the sized type aliases for the purpose of modular arithmetic! The type aliases do not encode conversion rank. — Kerrek SB, Jan 13 '17 at 16:59
Always enable recommended warnings. One of them is `-Wconversion`. — too honest for this site, Jan 13 '17 at 17:02
If you change from `uint8_t` to `unsigned int`, you'll get the behavior you expect. — Barmar, Jan 13 '17 at 17:02
@DarthRubik: "I am fairly certain that subtracting one `uint8_t` from another should result in another unsigned number". Nope. It evaluates to a `signed int` result. — AnT stands with Russia, Jan 13 '17 at 17:09
Gosh, so many compilers, all wrong the same way with such a simple piece of code. Perhaps we should educate those compiler writers better! — n. m. could be an AI, Jan 13 '17 at 17:26

Baum mit Augen · Accepted Answer · 2017-01-13T17:18:02.667

This is a bug with the version of gcc I am using.....right?

No, it's not. Something that simple being buggy in a big compiler like gcc is highly unlikely.

What happens is due to the "usual arithmetic conversions", specifically "integer promotion":

The unary - promotes a to int, then the (int)-2 gets converted back to uint8_t in the assignment, yielding c == 254 (which is the representative of the equivalence class of -2 in Z mod 2^8 that lies in [0, 2^8)).

Likewise, the binary + and - in the lines below that promote to int, so we end up with

d == (int)b - (int)a == (int)1 - (int)2 == -1

and

e == (int)b + (int)c == (int)1 + (int)254 == 255

So everything is working fine as mandated by the standard.

score 2 · Answer 2 · answered Jan 13 '17 at 17:06

The reason is that binary operators undergo integral promotion before doing the work, and since int can hold all possible values from uint8_t, that choice is used (see http://en.cppreference.com/w/cpp/language/implicit_conversion#Integral_promotion). Thus the subtraction is done as a signed operation.

When calculating e the act of storing a value in c already resulted in your expected modulo math, storing 254 which is then added to b's value of 1.

Is there a difference between unary - and n -

2 Answers2