Same-line vs. multi-lined bitwise operation discrepancy

Question

While writing a program for uni, I noticed that

unsigned char byte_to_write_1 = (0xFF << 2) >> 2; ==> 0xFF (wrong)
unsigned char byte_to_write_2 = (0xFF << 2);
byte_to_write_2 = byte_to_write_2 >> 2; ==> 0x3F (correct)

I don't understand what's causing the discrepancy... my best guess is that while modifying a byte with multiple operations on the same line, C "holds onto" the extra bits in a slightly larger datatype until the line is terminated so 0xFF << 2 is held as 11[1111 1100] instead of 1111 1100 so on the same-line shiftback, the result is 1111 1111 instead of 1111 1100.

What causes the difference in results? Thanks in advance...

I first noticed the issue in a larger code project but have been able to recreate the issue using a much more simple program.image of simplified code to showcase problem

Answer 1

The difference between these two code snippets

unsigned char byte_to_write_1 = (0xFF << 2) >> 2; ==> 0xFF (wrong)

and

unsigned char byte_to_write_2 = (0xFF << 2);
byte_to_write_2 = byte_to_write_2 >> 2; ==> 0x3F (correct)

is that in the second code snippet there is used the variable byte_to_write_2 to store the intermediate result of the expression (0xFF << 2). The variable can not hold the full integer result. So the integer result is converted to the type unsigned char that can store only one byte.

The maximum value that can be stored in an object of the type unsigned character is 0xFF

— maximum value for an object of type unsigned char
UCHAR_MAX 255 // 28 − 1

that is equal to 255. While the expression 0xFF << 2 that is equivalent to 255 * 4 can not fit in an object of the type unsigned char.

In the first code snippet the intermediate result of the expression (0xFF << 2) has the type int due to the integer promotion and can be used without a change in the full expression (0xFF << 2) >> 2.

Consider the outputs of these two calls of printf

printf( "0xFF << 2 = %d\n", 0xFF << 2 );
printf( "( unsigned char )( 0xFF << 2 ) = %d\n", ( unsigned char )( 0xFF << 2 ) );

They are

0xFF << 2 = 1020
( unsigned char )( 0xFF << 2 ) = 252

Answer 2

unsigned char byte_to_write_1 = (0xFF << 2) >> 2;  // 0xFF

0xFF is an int. (Obtaining 0xFF from an unsigned char wouldn't change anything since it would get promoted to an int.) 0xFF << 2 is 0x3FC. 0x3FC >> 2 is 0xFF.

---

unsigned char byte_to_write_2 = 0xFF << 2;  // 0xFC
byte_to_write_2 >>= 2;                      // 0x3F

We've already established that 0xFF << 2 is 0x3FC. But you assign that to an unsigned char which is presumably only 8 bits in size. So you end up assigning 0xFC instead. (gcc warns about this if you enable warnings as you should.)

And of course, you get the desired value when you right-shift that.

---

Solutions:

(unsigned char)( 0xFF << 2 ) >> 2

( ( 0xFF << 2 ) & 0xFF ) >> 2

0xFF & 0x3F

Demo on Compiler Explorer.