How to convert 2 bytes into a signed short in C

Question

I have 2 bytes that I need to convert to a signed short number. For example, I have separate bytes (0000 0001) and (0000 0002) in binary. How can I convert these to a signed short value?

Answer 1

If the bytes are held in a signed datatype, such as signed char or int8_t, then it is pretty straightforward:

signed short combine_signed(signed char byte1, signed char byte2) {
  return byte1 * 256 + (uint8_t)byte2;
}

Multiplication is used here, rather than a shift operation, but it is expected that the compiler will actually insert an appropriate shift operation. The C standard does not specify the result of left shifting a negative number, so a left shift cannot be used in portable code.

If the bytes are in an unsigned type or a type wider than 8 bits, then the simplest approach is to first convert the high-order byte to a signed value and then proceed as above. Converting to a signed value cannot be done with a simple cast because such a conversion would be an integer overflow, whose results are not specified by the C standard. So a portable program must explicitly test the high order bit:

signed short combine(int byte1, int byte2) {
  // This code assumes that byte1 is in range, but allows for the possibility
  // that the values were originally in a signed char and so is now negative.
  if (byte1 >= 128) byte1 -= 256;
  return byte1 * 256 + (uint8_t)byte2;
}

(Both gcc and clang for x86, compiled with -O2 or better, manage to reduce that to a simple three-instruction sequence without multiply or conditional.)

Answer 2

Given:

char msb = 0x01 ;
char lsb = 0x02 ;

Then:

short word = (msb << 8) | (lsb & 0xff) ;

will result in word having the value 0x0102 (or 258₁₀).

Since you asked for a signed short, however that is not a very interesting example. For:

char msb = 0x80 ;
char lsb = 0x02 ;

word would have 0x8002, which for a 16 bit short would be -32766.

However on an implementation where short were longer than 16 bits (as is allowed), the result will be interpreted as +32770. It is far safer in this circumstance to use the fixed sized int16_t type defined in stdint.h to avoid any potential implementation dependency.

 int16_t word = (msb << 8) | (lsb & 0xff) ;

This can be simplified somewhat by using uint8_t instead of char which may be either signed or unsigned:

uint8_t msb = 0x80u ;
uint8_t lsb = 0xFFu ;
int16_t word = (msb << 8) | lsb ;

Will result in word = -32513, whereas if lsb and msb were char and char were signed in the implementation, then the result would be -1 due to implicit type promotion and sign extension of lsb.

This remains not strictly well defined because, the left-hand expression promotes to unsigned int and can result in a value not representable as a int16_t, and in that case the behaviour is implementation defined. That said it would be an unusual implementation that did anything other then simply copy the bits verbatim, which is why it works, and the above is idiomatic.

If short is explicitly required, to guarantee a correctly signed result regardless of the length of short, you can explicitly cast to int16_t and assign to a short (or even an int):

 short word = (int16_t)((msb << 8) | (lsb & 0xFF));

A solution is also possible using a union, but given the tags on this question, it seems unlikely that it is an acceptable solution in this case. It has the merit of avoiding any implementation defined behaviour and arcane type promotion and implicit conversion rules, but you do have to deal with endian-ness:

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
  #define LSB 0
  #define MSB 1
#else
  #define LSB 1
  #define MSB 0
#endif

union
{
    int16_t word ;
    uint8_t byte[2] ;
} reinterpret ; 

reinterpret.byte[MSB] = 0x80u ;
reinterpret.byte[LSB] = 0xFFu ;

short word = reinterpret.word ;

https://onlinegdb.com/Byth1N3yr

Answer 3

Assuming 0x01 is the MSB and 0x02 the LSB, then unsigned short foo = 0x01 << 8 | 0x02; would be enough. However, this would imply that unsigned short is at least 16-bit (it depends on the implementation, search for stdint.h for fixed-size)