Misaligned memory access

[Jez]

Hi all,

Do any of you guys have experience of using misaligned memory accesses for any reason?

Usually, it's something you want to avoid, because it's both a non-portable behaviour, and is slower than an aligned access.
However my current project has compelling reasons to do so. (It's an engine for running Conways "game of life" if you're interested).

For instance this simple fragment:

int foo[100];
int word = 3;
int offset = 1;
int *misaligned = (int*)((char*)&foo[word] +offset);
*misaligned += 0x12345678;

This takes array foo, and updates bytes 13 - 16 within it.

I made foo an array of ints here, because it's accessed that way elsewhere. This isn't a totally fictitious example, I actually do something like this in my code.

Is there a neater way to do this? All those casts look untidy!

[xErath]

Untidy?? Don't worry, they're pretty readble, and when working with memory adresses that's what you have to do. But...
maybe this is cleaner??

int foo[100];
int word = 3;
int offset = 1;
char *ptr = (char*)foo;
//use sizeof(int) instead 4 if your concearning portability
int *misaligned = (int*)(ptr+word*4+offset);
*misaligned += 0x12345678;

[Jez]

Thanks for that vote of confidence xErath.

I like your way too (seems a bit purer somehow) but I like to have the array index explicit in the code (in reality it's a 2D array)

FYI, the core of this program originated on 68000 processor, but written in assembly language. I decided to dust it off + create a win86 version on the same principle.

Doing weird pointer mangling is easy in 68k, but I have to work around C to do it here it seems.