Is this Integer Promotion? How does it work?

Question

I was just experimenting and I tried out two printf()s.

unsigned char a = 1;
a = ~a;
printf("----> %x %x %x %x", ~a, a, ~a, ++a);

This one gave the output

----> ffffff00 ff ffffff00 ff

Next one was

unsigned char a = 1;
printf("----> %x %x %x %x", ~a, a, ~a, ++a);

This one gave the output

----> fffffffd 2 fffffffd 2

Now, I know what '++' does and '~' does. I also know that the sequence of operation inside printf is from the right.

But could some one explain the difference in the number of bytes printed? A total explanation of output would be helpful of course, but I am more interested in the number of bytes and the difference in both cases [especially in the printf a and ~a parts].

EDIT:

OK, looks like the ++ part and my mistake of "I also know that the sequence of operation inside printf is from the right" has prompted every post other than the answer I was hopefully looking for. So may be the way I asked was wrong.

I will try again,

unsigned char a = ~1;
a = ~a;
printf("----> %x", a); 

OUTPUT: ----> 1

unsigned char a = ~1;
printf("----> %x", ~a);

OUTPUT: ----> ffffff01

Why this difference?

Answer 1

printf("----> %x %x %x %x", ~a, a, ~a, ++a); actually invokes undefined behavior because you have a side effect on a and other expressions depending on the same lvalue. So anything can happen and it is hopeless to try and explain the output produced.

Assuming 32 bit ints in 2's complement representation, if you wrote

printf("----> %x %x %x %x", ~a, a, ~a, a + 1);

You would get different and less surprising output:

ffffff01 fe ffffff01 ff

Let me explain what is going on:

a = ~a;

a contains 1, is converted to an int with the same value, the ~ operator applied to 1 computes to -2, converting that back to unsigned char gives 254 or 0xfe.

The arguments to printf are then computed as follows:

• ~a: 0xfe is converted to int and all bit are complemented, yielding 0xffffff01.

• a is converted to int with the same value and printed as fe.

• ~a again of course gives the same output.

• a+1: a is converted to int before incrementing by one, result is 255, prints as ff.

The explanation for your surprising outputs is that a is first converted to int and then the computation is done on the int value.

Answer 2

a = ~a; You have integer promotion on this line already, since the ~, like most operators in C, promotes the operand according to the rules of integer promotion.

The character containing value 1 gets integer promoted to an int containing the value 1, before the operation is done. Assuming 32 bit int, the result of ~a is a negative, two complement variable with hex value 0xFFFFFFFE.

You then show this result back into the unsigned char, it will truncate the result and only grab the raw binary value of the least significant byte, that is: 0xFE.

I also know that the sequence of operation inside printf is from the right.

No. The order of evaluation of function parameters in not specified by the standard. The compiler is free to evaluate them in any order it likes, and you cannot know or assume any particular order.

Even more problematic is that there is no sequence point between the evaluation of the different parameters. And since in your case you are using the same variable more than once, each access to the variable is unsequenced and your program invokes undefined behavior. Meaning that anything can happen: weird outputs, program crashes, memory corruption etc etc.

Furthermore, printf is a special case, being an obscure, variadic function. All such functions have particular rules for promotion of the arguments ("the default argument promotions"). So regardless of what promotions that happen or don't happen before you pass the result to printf, printf will ruin everything by applying its own integer promotion to the parameter.

So if you wish to toy around with promotion, printf is a very bad choice for displaying the result. Try using the sizeof operator instead. printf("%zu", sizeof(~a)); will for example print 4, because of integer promotion.