将无符号字符数组转换为 C 中的有符号短整型

Question

I want to convert an array of unsigned char to a signed int! I've already done some try, and the conversion works for the single element like this:

  unsigned char byte[2];
  signed char *valueS[2];
  byte[0] = 0b11110111;
  byte[1] = 0b00001001;

  //Conversion
  for(int i = 0; i < 2; i++)
  {
     valueS[i] = (signed char*)&byte[i];
  }

  //Result
  printf("Val 0 -> %d \n", *valueS[0]); // print -9 Correctly
  printf("Val 1 -> %d \n", *valueS[1]); // print 9 Correctly

  //But when i try to print a 16 bit signed
  printf("Int %d \n", *(signed short*)valueS); //It doesn't work! I expected -2295

How can i get the 16 bit signed int from that unsigned char array? Thank you in advance!

Answer 1

How can i get the 16 bit signed int from that unsigned char array?

Supposing you mean you want to obtain the int16_t whose representation is byte-for-byte identical to the contents of an arbitrary array of two unsigned char , the only conforming approach is to declare an int16_t object and copy the array elements to its representation. You could use the memcpy() function to do the copying, or you could do it manually.

For example,

#include <stdint.h>

// ...

    unsigned char byte[2] = { 0xF7, 0x05 };
    int16_t my_int;
    unsigned char *ip = (unsigned char *) &my_int;

    ip[0] = byte[0];
    ip[1] = byte[1];
    printf("Int %d \n", my_int);

You might see a recommendation to use a pointer aliasing trick to try to reinterpret the bytes of the array directly as the representation of an integer. That would take a form similar to your code example, but such an approach is non-conforming, and formally it yields undefined behavior. You may access the representation of an object of any type via a pointer to [ unsigned ] char , as the code in this answer does, but, generally, you may not otherwise access an object via a pointer to a type incompatible with that object's.

Note also that the printf above is a bit sloppy. In the event that int16_t is a different type from int , such as short int , the corresponding printf directive for it will have a length modifier in it -- likely %hd . But because of details of the way printf is declared, it is the result of promoting my_int to int that will be passed to printf . That rescues the mismatch, and in practice, the printed result will be the same as if you used the correct directive.