3 each 8bit chars from a 32bit long int

[Brucewd]

If I have a 32 bit address that I can incroment with memadd++

long int memadd;
char memBiteLow;
char memBitemed;
char memBiteHigh;

memadd = 0x00ABCDEF;

and I need

I need

MemBiteLow to hold EF
MemBiteMed to hole CD
MemBiteHigh to hold AB
do I use union? struct?

I do not seem to be able to make union work. All three chars have EF.

[itCbitC]

Point to memadd using a char*, walk along it and store the dereferenced value in the high(low), med and low(high) variables, depending on the endianness of the machine.

[anduril462]

Look into the bit shift (>>) and bit-wise AND (&) operators. Something like:

unsigned long memadd = 0x00ABCDEF;
unsigned char memByteLow;
unsigned char memByteMed;
unsigned char memByteHigh;

memByteMed = (unsigned char) ((memadd & 0x0000FF00) >> 8);

Note that you always want to use unsigned values when using the bit shift operators. Otherwise, you will run into problems if the left-most bit is a 1 (it will be undefined or implementation defined behavior). Also, for future reference, there are left-shift operator (<<), bit-wise OR (|), bit-wise XOR (^) and bitwise NOT (~) operators. You should read your books and check some tutorials on how to use them. We have one here, and Google should turn up several more.

[Brucewd]

Thanks. That is a brute force solution. I was looking for something more elegant.

[anduril462]

Hmm...I wouldn't consider itCbitC's solution or mine to be "brute force". Actually, my solution is the only portable one I'm aware of (it works regardless of endianness of the machine). I would argue that code that doesn't need to check endianness before extracting bits is a lot more elegant than code that does. Here's a solution using a union that I really don't recommend, but might fit your definition of "elegant".

union {
    unsigned long memadd;
    unsigned char memBytes[sizeof(unsigned long)];
} mem;

if little endian
    low = mem.memBytes[0];
    med = mem.memBytes[1];
    high = mem.memBytes[2];
else
    low = mem.memBytes[3];
    med = mem.memBytes[2];
    high = mem.memBytes[1];

[Brucewd]

Thanks. I am using am 8bit micro that is time critical. I am reading a large memory. It is a lot faster to grab bites out of a 32 bit int that it is to do all the bit shifting. Again thanks for your help. My C classes were in 1985.

[Brucewd]

This works beautifully, thank you!

[anduril462]

You're welcome. And just to bring you up to date a bit, C is largely the same language it was in 1985, but a good amount has changed too, and things have become much more standardized (there wasn't even a standard in 1985, the first one was in 1989). I recommend you peruse the C99 standard to see the current state of the language (it's a 12 year old standard, but it's still the standard). Most commercial compilers come close to the C99 standard, if they don't fully adhere to it. We have a draft copy here, which is just about as good as the real thing (the real one costs real money).

[quzah]

Thanks. I am using am 8bit micro that is time critical. I am reading a large memory. It is a lot faster to grab bites out of a 32 bit int that it is to do all the bit shifting.

Shifts are pretty fast. As much as I enjoy tinkering with unions, I doubt shifting is as slow as you think it is.


Quzah.

[TheBigH]

Shifts are pretty fast. As much as I enjoy tinkering with unions, I doubt shifting is as slow as you think it is.


Quzah.

Wow, I never thought I'd meet someone who actually likes union-fiddling. I hate the rotten things. But it'd be a boring world if we were all alike.

[AndrewHunter]

Wow, I never thought I'd meet someone who actually likes union-fiddling. I hate the rotten things. But it'd be a boring world if we were all alike.

Haha.....quzah isn't what we would call "normal".

[stahta01]

Shifts are pretty fast. As much as I enjoy tinkering with unions, I doubt shifting is as slow as you think it is.


Quzah.

Some micro-controllers are very slow.
And, some might have to really shift it 8 times per byte because of poor compiler optimization of the C code.

Tim S.

[quzah]

Wow, I never thought I'd meet someone who actually likes union-fiddling. I hate the rotten things. But it'd be a boring world if we were all alike.

You can do interesting things with them. For example, this bit of swapping bytes around with clearly labeled identifiers. For someone not used to shifting bits, it can give a clear indicator of what's going on.


Quzah.

[CommonTater]

Going back to the union idea...

union t_TRANSLATE
  { unsigned long int dword;
     struct byte
       { unsigned char b0;
         unsigned char b1;
         unsigned char b2;
         unsigned char b3; }}
     TRANSLATE;

   TRANSLATE.dword = 0xFAFAFAFA;
    printf("%d", TRANSLATE.byte.b2);

Pretty simple really....

[quzah]

What kind of crazy person starts numbering at 1?


Quzah.