Thread: Casting pointer to unsigned short

Originally Posted by cks2k2

I have as input a char pointer: char* source.
Assume that source contains the string "helloworld".
Then we do this:

Code:

unsigned short a = *((unsigned short*)source);

I understand that source is a pointer to a character, so source is essentially just a 32-bit integer of some memory address in the system i.e. 0x001b5b15, and de-referencing it will give me "helloworld". But I'm not sure what happens when I cast it to unsigned short. I believe that it will truncate the first 2 bytes and return only the last 2 bytes: 0x00005b15 and de-referencing this memory address will return some unknown value. Is my understanding correct?

No.

Address is not changed.
Dereferencing it as char will not give you "helloworld".
It will give you 'h'
When you cast it to unsigned short* - it will be same address - but the destination will be split in two-chars patterns istead of 1
so dereferencing it will bring
('h' << 8) | 'e'

or

('e' << 8) | 'h'

depending on the endianess

I just wanted to try to make vart's explanation a bit closer to spoken language

Eg, the pointer type tells how many bits will be read from the address it points to.

With char pointer, we will read 8 bits (one byte).
When we cast the char pointer to short int pointer, tha data pointer points to is assumed to be short integer.
Now dereferencing short int pointer will give you 16 bits (2 bytes) which is the size of a short.

The role endianess plays is in how processor handles the data. There is two types of systems, little and big endianess systems. In little endianess system, the least significant bytes (note not bits, bytes) will be first. In big endianess machines the most significant bytes are first.

so, number short integer 1, divided into bytes will be like 0x00 0x01 in big endianess machines memory.
little endianess machine has it as 0x01 0x00

Because chars are just one byte wide, they will be stored similarly in both big and little endianess machines. But when we store 2 chars, lets say 0x01 and 0x00 in continuous memory block, and then read them back as short integer, we'll get different value depending on architecture. This can be done by casting pointer to char array to pointer to short.

Eg, we place data as 0x0100 in array, now when big endianess machine reads this as short, it interpretes value to be 0x100 (256 in decimal notation)

When little endianess machine reads the data, it is interpreted to mean value 0x1 (1 in decimal notation)

'0' character is not the same as 0 integer

int length = (source[0] - '0') * 10 + (source[1] - '0')

Again as Vart explained, characteric "06" is not same as 0x00 0x06. You can google for ASCII table, to see what are the actual values in memory, representing characters.

Besides, assuming you use PC, you will propably be using little endian system. So if you have chars 0x00 0x06 in memory, it will be interpreted as short 0x0600. You should have 0x06 0x00 as the lenght (which would be interpreted as short 0x0006).

Doing a decimal to hex translation of 13872 proves Maz right: The value is 0x3630, which is '60'.

You probably can't use this little trick in a way that is meaningful, you simply have to read each digit and translate to an integer (subtract '0' and multiply by 10 then add second digit).

--
Mats