移位不正确？

Question

I am programming the 8051 in C using the Si Labs IDE. I currently have three bytes: address_byte3, address_byte2, and address_byte1 . I then initialized a variable address_sum to be an unsigned long int then did the following operation on it...

address_sum=(address_byte3<<16)+(address_byte2<<8)+(address_byte1);

This operation would lead me to believe that the value loaded into address_sum if address_byte3, address_byte2, & address_byte1 were 0x92, 0x56, & 0x78 , respectively, would be 0xXX925678 . Instead I am getting a value of 0xXX005678 . My logic seems sound but then again I am the one writing the code so I'm biased and could be blinded by my own ignorance. Does anyone have a solution or an explanation as to why the value for address_byte is "lost"?

Thank you.

Answer 1

Variables shorter than int are promoted to int when doing calculations on them. It seems that your int type is 16-bit, so shifting it by 16 bits doesn't work right.

You should explicitly cast the variables to the result type ( unsigned long ):

address_sum = ((unsigned long)address_byte3<<16) +
              ((unsigned long)address_byte2<<8) +
              (unsigned long)address_byte1;

The last casting is superfluous but doesn't hurt.

Answer 2

A shift of a 16-bit int/unsigned , as well explained by @anatolyg will only result in a 16-bit answer.

I avoid casting, as a general promotion scheme, as sometimes it may narrow the result as code evolves over time and the maintainer uses wider operands.

Alternatives:

((type_of_target) 1) * : This will insure each operation is at least the width of the target.

unsigned long address_sum;
...
address_sum = (1UL*address_byte3<<16) + (1UL*address_byte2<<8) + address_byte1;

Assign to the destination and then operate:

address_sum = address_byte3;
address_sum = address_sum << 8 + address_byte2;
address_sum = address_sum << 8 + address_byte1;

A sneaky, thought not pleasant looking 1-line alternative. Recall * + higher order precedence than shift

address_sum = (0*address_sum + address_byte3 << 16) + 
              (0*address_sum + address_byte2 <<  8) + address_byte1;

---

Consider @Eugene Sh. concern and use 8-bit unsigned "bytes".

Answer 3

My preference is a variation on chux

bigger declaration address; byte declaration a,b,c;

address =a; address<<=8;
address|=b; address<<=8;
address|=c;

Despite being the most verbose all of the answers thus far should optimize into basically the same code. But would have to test the specific compiler to see. Can the 8051 shift more than one bit at a time per instruction anyway? Dont remember.