Cast char to short

Question

char *buffer; 
short num; 
memcpy(&num, buffer, sizeof(short));

*buffer - pointer to the buffer, where number is situated in HEX view. I want to put this number in the variable num without calling memcpy. How can I do it?

number = (short) buffer; //DOESN'T work!

@Noctua: This wont take `sizeof(short)` from `buffer`, but just `sizeof(char)` and promote it to a `short`. Wont get the expected result. :) — raj raj, May 31 '13 at 06:59
It is **important** to know the endianness (the order of the bytes) in the buffer. Without that information any solution, be it your `memcpy`, the undefined cast or the byte shifting of perreal will be wrong. — Patrick Schlüter, May 31 '13 at 09:42
@tristopia that depends on how the short got there, right? If it were created on the platform and memcpy'd there, then you wouldn't have to worry about it, right? — xaxxon, May 31 '13 at 15:46
In the case of `memcpy` it would be indeed not a problem. My comment was more in the context of perreal's answer which assumed a big-endian value in the buffer. — Patrick Schlüter, May 31 '13 at 16:02
@xaxxon if it was created on the platform, how come it ended up in a character buffer? It would have been in a short to begin with! No, the fact that it's in a character buffer clearly indicated that it's pulled in from an external source, and then all bets are off. — Mr Lister, May 31 '13 at 18:52

score 4 · Answer 1 · answered May 31 '13 at 07:07

4

All answers so far suggested using *(short *)buf, but that's not any good - it breaks the strict aliasing rule (the alignment of short is greater than that of char, so you can't do this without invoking undefined behavior).

The short answer is: you'd be better off using memcpy(), but if you really don't want that, then you can use unions and "type punning" (note that this may result in a trap representation of the buffer of bytes which may or may not be what you want):

union type_pun {
    char buf[sizeof(short)];
    short s;
};

union type_pun tp;
tp.buf[0] = 0xff;
tp.buf[1] = 0xaa; // whatever, if `short' is two bytes long
printf("%hd\n", tp.s);

answered May 31 '13 at 07:07

Calling memcpy for 2 bytes - is prodigally. – user2439344 May 31 '13 at 07:24
@user2439344 It will be optimized out, and it will make your program behave *correctly.* – May 31 '13 at 07:24
This doesn't help if the source data is already in a char array, though. You still have to load it into the union with a memcpy or somsething, right? at which point, why not just use memcpy directly to a short. – xaxxon May 31 '13 at 09:54
@xaxxon Right, but still better than UB. – May 31 '13 at 09:59

xaxxon · Answer 2 · 2013-05-31T06:58:59.090

2

Based on your memcpy of sizeof(short) bytes, I'm guessing you want to get the first sizeof(short) bytes from where buffer is pointing at.

number = * (short *) buffer;

will do that for you, as other have pointed out.

You cannot take the pointer's address and put it in a short, so you need to dereference it to get the value in the memory instead.

edited May 31 '13 at 06:58

answered May 31 '13 at 06:50

xaxxon

19,189
5
50
80

***This answer is WRONG, stop upvoting it!*** – May 31 '13 at 07:11
Given that being able to do this is a common requirement and most people get it wrong, I wonder why there isn't a language feature 'number = interpret_as(buffer)' or some such thing that does this in a safe way. – jcoder May 31 '13 at 07:42
Yeah, it's only sort of wrong, except it works, right? it's frustrating. – xaxxon May 31 '13 at 07:51
@trisopia But it's not the same. I don't want to copy the data anywhere, I want to say please access the data at this address as if it's a "short" and please arrange to make sure this is safe. Which in many cases won't require any actual work by the compiler. memcpy makes a copy of the data which isn't the same. I'm aware it might optimize out the copy but it's not the same thing really at all. – jcoder May 31 '13 at 09:43
Ok, I was too literal with your example `'number = interpret_as(buffer)'` which is perfectly translated by `memcpy(&number, buffer, sizeof (short));` but I hadn't considered it could be part of an expression. – Patrick Schlüter May 31 '13 at 16:07

score 2 · Accepted Answer · edited May 31 '13 at 09:51

2

For two byte short:

number = (short)(
           ((unsigned char)buffer[0]) << 8 | 
           ((unsigned char)buffer[1])
          );

For different short:

for (int i = 0; i < sizeof(short); i++)
        number = (number << 8) + ((unsigned char) buffer[i]);

or you'll have some macros for each size.

Also, see tristopia's comment about this making assumptions about endianness.

edited May 31 '13 at 09:51

xaxxon

19,189
5
50
80

answered May 31 '13 at 06:51

perreal

94,503
21
155
181

That's going to pull in multiple bytes -- I'm not sure that's what he wants. I guess we'd have to ask. – xaxxon May 31 '13 at 06:53
I think size of short is 2, so you will be reading out of the "1 byte" char :S – Alfonso Nishikawa May 31 '13 at 06:54
@xaxxon, OP has 2 bytes in memcpy so I tried to copy 2 bytes. – perreal May 31 '13 at 06:55
Oh, didn't notice xD You nailed :) – Alfonso Nishikawa May 31 '13 at 06:55
@perreal This code invokes undefined behavior, see my answer. – May 31 '13 at 07:08
***This answer is WRONG, stop upvoting it!*** – May 31 '13 at 07:10
@perreal The accepted answer is still wrong, yet it's getting upvoted. That's why we can't have nice things on SO... – May 31 '13 at 07:20
@H2CO3, don't worry though, future readers will see all the discussion – perreal May 31 '13 at 07:23
@user2439344, this one is correct now he is referring to xaxxon's answer – perreal May 31 '13 at 07:26
@H2CO3 What about your answer I didn't get why I need union?? I have pointer to the input buffer. All what I want is to get first 2 bytes (if short is 2 bytes) and put it in the variable of type short – user2439344 May 31 '13 at 07:26
@perreal what if short is not 2 bytes? – user2439344 May 31 '13 at 07:27
@user2439344 You can't do `*(short *)buf`, because of different alignment requirements of `short *` and `char *`. – May 31 '13 at 07:28
@perreal Are you sure? number = (number << 8) + ((unsigned char) buffer[i]); number has not been initialized yet – user2439344 May 31 '13 at 07:34
@user2439344, I assumed it is initially 0 – perreal May 31 '13 at 07:38
@perreal ok! I am not sure that it is more productive than just calling memcpy. Anyway thanks! – user2439344 May 31 '13 at 07:41
1

There's still a portability problem in your code. It supposes BIG-ENDIAN storage of the bytes in the buffer. OP's `memcpy` solution implies the same endianness for the buffer and the destination variable. – Patrick Schlüter May 31 '13 at 09:38
Why those casts? The `<<` promotes to at least `int` anyway. – Baum mit Augen Jul 19 '15 at 11:47

score 0 · Answer 4 · answered May 31 '13 at 06:55

0

Assuming that with "situated in HEX view" you mean the number is stored in the string like "89AB", you can use the strtol function.

char* end;
num = (short)strtol(buffer, &end, 16);

This function converts the string to a long integer. There is no corresponding function that converts to a short directly, so you'll have to do a (short) anyway, but that wasn't the problem, was it?

answered May 31 '13 at 06:55

Mr Lister

45,515
15
108
150

Thanks. I mentioned "put two bytes in the short variable" I am misunderstood myself) – user2439344 May 31 '13 at 07:09
@user2439344 Yeah, I understood that later. Not sure what's the underlying cause of your problem though. I mean, how did the short value end up in a char* in the first place? – Mr Lister May 31 '13 at 07:11

Cast char to short

4 Answers4

Linked