Question

I have a string:

“the quic”

Which is passed on to a function where the bits that make up the string are stored in an unsigned __int64. Resulting in the following output:

0111010001101000011001010010000001110001011101010110100101100011

However when I pass a string containing these values:

0xDE, 0x10, 0x9C, 0x58, 0xE8, 0xA4,
0xA6, 0x30, ‘\0’

The output isn’t as correct as I expected:

1111111111111111111111111111111111111111111111111010011000110000

I’m using the same code as in the first string, which reads:

(((unsigned __int64)Message[0]) << 56) | (((unsigned __int64)Message[1]) << 48) |
(((unsigned __int64)Message[2]) << 40) | (((unsigned __int64)Message[3]) << 32) |
(((unsigned __int64)Message[4]) << 24) | (((unsigned __int64)Message[5]) << 16) |
(((unsigned __int64)Message[6]) << 8) | (((unsigned __int64)Message[7]));

Answer 1

I guess you did something like this,

char a[] = {0xDE, 0x10, 0x9C, 0x58, 0xE8, 0xA4, 0xA6, 0x30};

change it to unsigned char will solve your problem,

unsigned char a[] = {0xDE, 0x10, 0x9C, 0x58, 0xE8, 0xA4, 0xA6, 0x30};

I’ve tried both, the char version will be wrong in VC++, but unsigned version will be correct.

If you want to know the reason, look at a simpler version,

char a = 0xDE;
unsigned char b = 0xDE;

What’s the difference? 0xDE is an int type. For the first one, you are converting int to signed char, for the second one, you are converting int to unsigned char.

From standard 4.7/2, 4.7/3

If the destination type is signed, the
value is unchanged if it can be
represented in the destination type
(and bit-field width); otherwise, the
value is implementation-defined.

If the destination type is unsigned,
the resulting value is the least
unsigned integer congruent to the
source integer (modulo 2n where n is
the number of bits used to represent
the unsigned type). [ Note: In a two’s
complement representation, this
conversion is conceptual and there is
no change in the bit pattern (if there
is no truncation). —end note ]