Converting 24 bit integer (2s complement) to 32 bit integer in C++

Question

The dataFile.bin is a binary file with 6-byte records. The first 3 bytes of each record contain the latitude and the last 3 bytes contain the longitude. E

Answer 1

When an unsigned char is casted to an int the higher order bits are filled with 0's

When a signed char is casted to a casted int, the sign bit is extended. ie:

int x;
char y;
unsigned char z;
y=0xFF
z=0xFF
x=y;
/*x will be 0xFFFFFFFF*/
x=z;
/*x will be 0x000000FF*/

So, your algorithm, uses 0xFF as a mask to remove C' sign extension, ie

0xFF == 0x000000FF
0xABCDEF10 & 0x000000FF == 0x00000010

Then uses bit shifts and logical ands to put the bits in their proper place.

Lastly checks the most significant bit (newInt & 0x00800000) > 0 to decide if completing with 0's or ones the highest byte.

Answer 2

I am not understanding how I can store the CHAR "data" into an INT.

Since char is a numeric type, there is no problem combining them into a single int.

Since its receiving 24 integers of information stored into a BYTE

It's 24 bits, not bytes, so there are only three integer values that need to be combined.

An easier way of producing the same result without using conditionals is as follows:

int interpret24bitAsInt32(byte[] byteArray) {     
    return (  
        (byteArray[0] << 24)
    |   (byteArray[1] << 16)
    |   (byteArray[2] << 8)
    ) >> 8;  
}

The idea is to store the three bytes supplied as an input into the upper three bytes of the four-byte int, and then shift it down by one byte. This way the program would sign-extend your number automatically, avoiding conditional execution.

Note: This code is not portable, because it assumes 32-bit integer size. To make it portable use <cstdint> types:

int32_t interpret24bitAsInt32(int8_t[] byteArray) {
    return (  
        (byteArray[0] << 24)
    |   (byteArray[1] << 16)
    |   (byteArray[2] << 8)
    ) >> 8; 
}

It also assumes that the most significant byte of the 24-bit number is stored in the initial element of byteArray, then comes the middle element, and finally the least significant byte.