Thread: shortening this short code? : binary to int casting

I have a 4bytes in a char buffer and I wish to cast to int.
I'm currently using the code below..

int *aa = (int*)aBuffer;
int bb = *aa;

Can i shorten this code somehow? I seem to have one more int variable than necessary.
My pointer skills are not too great.

Something like this..

int bb = (int)&aBuffer

..would be much prettier, but i can guess it does not work.

Any ideas?

You'll want to save this (honest)

Code:

#include <stdio.h>
#include <stdlib.h>

int main() {
	char *Int=malloc(4);
	int X=421500666, *xx=&X;
	int OldGit; /* this one's for you */
	Int=(char*)xx;
	printf("%d\n",*(int*)Int);
	/* everything good to here...eureka! */
	OldGit=*(int*)Int; 	/* !!!! */
        OldGit++;
	printf("%d\n",OldGit);
	return 0;
}

You're gonna love the output too.

So...

int aa = *(int*)aBuffer;


great!

Cheers

It's slightly long winded. You don't need *xx at all, you can just say

Code:

Int=(char*)&X;

One thing you can't do is this:

Code:

char Int[4];

which is slightly strange.

Originally Posted by OldGit

I dont quite follow that one, your casting with a char pointer the address of buffer, and storing in an int.

Now I'm confused. ha. But thankyou, thats solved my predicament.

&X would be the address of the location where the int X is stored. Remember *xx=&X? So &X points to X.

The cast allows Int (a char pointer) to point to X.

Shall I tell you about alignment exceptions and bus errors, or do you want to find that out for yourself first?

Originally Posted by Salem

Shall I tell you about alignment exceptions and bus errors, or do you want to find that out for yourself first?

Oh please do!

Originally Posted by MK27

Oh please do!

What Salem is referring to is that some processors (in fact most that are not x86) do not accept memory reads from unaligned addresses, e.g. a 4-byte word must be aligned to a 4-byte block in memory. Bus error is the common message from the processor for "unaligned access", but it is sometimes called other things.


Some processor & OS combinations use the exception by the processor to fetch the data byte-by-byte into a longer data item (which then takes 10-100 times longer than a single word read), other processors simply cause an error, much like invalid memory address exceptions (page-fault, segmentation violation or whatever you call it).

So for portable code, copying byte by byte is the correct thing to do.

--
Mats

Originally Posted by matsp

What Salem is referring to is that some processors (in fact most that are not x86) do not accept memory reads from unaligned addresses, e.g. a 4-byte word must be aligned to a 4-byte block in memory. Bus error is the common message from the processor for "unaligned access", but it is sometimes called other things.

Ugg. Well, who the $%#^ doesn't use an x86 processor anyway?! I'm not sure how this applies here -- shouldn't char *Int=malloc(4) and int X be aligned properly?

Some processor & OS combinations use the exception by the processor to fetch the data byte-by-byte into a longer data item (which then takes 10-100 times longer than a single word read), other processors simply cause an error, much like invalid memory address exceptions (page-fault, segmentation violation or whatever you call it).

So for portable code, copying byte by byte is the correct thing to do.

So you would bitshift from Int into X?

Code:

#include <stdio.h>
#include <stdlib.h>

int main() {
	char *Int=malloc(4);
	int X=421500666, i;
	int OldGit=0; 
	Int=(char*)&X;
	printf("%d\n",*(int*)Int);
	/* everything good to here...eureka! */

	for (i=0; i<4; i++) OldGit+=Int[i]<<i*8;
        
	printf("%d\n",OldGit);
	return 0;
}

For some reason this does not quite work:
421500666
421434874

??

The char * is signed, so some parts of the number may be negative - probably not what you want.

Yes, malloc will be aligned to (at least) the size of double, one would expect (or the size of the allocation, whichever is smaller, and again this is the MINIMUM alignment, it may well be aligned to cache-lines or some other larger boundary).

But the original post says NOTHING about malloc.



--
Mats

Originally Posted by EVOEx

That should work .

It does! I am surprised, I would have thought the byte values would be the same either way, since Int is just a pointer to a (signed) int. But I guess one of the middle bytes counted as negative, because of course this works too:

Code:

 for (i=0; i<4; i++) OldGit+=(unsigned char)Int[i]<<i*8;

And it works with negative numbers too.

Still don't quite get this "alignment exceptions and bus errors" scare tho.

Originally Posted by MK27

Still don't quite get this "alignment exceptions and bus errors" scare tho.

Well, if you assume all of the world uses x86, then you can ignore it. If you ever need your code to work on Sparc, Alpha, 68K, 29K, ARM, Mips or some other processor that ISN'T x86, then any code that casts small type pointers (char *, short *, int *) to larger types (e.g. int *, long * or double * ) needs careful consideration or checking that the address is still valid for that type. If it is not (e.g. the data is in an arbitrarily aligned packet of data from a network port) then you need to shuffle bytes.

--
Mats