Thread: Bitwise set and mask issue

Hi,

I have this piece of code, just testing the set and mask functions. Here I have a original hex string ABC and I want to put it into result in reverse. I have the mask as 0xF (1111) and take each letter at a time and set it in result, then I left shift the result var bits 4 places to make room for the next letter and right shift the original var 4 bits to get at the next letter (4 bits). However running this code does not turn ABC into CBA but rather F. Going through the code again and again - I can't see what's wrong with it. Can you? The vars are unsigned ints (no 2 complement here).

Code:

int main(void)
{
  unsigned int original = 0xABC;
  unsigned int result = 0;
  unsigned int mask = 0xF;          /* rightmost 4 bits 1111 F is 16 over 4 bits */
  
  printf("\nOriginal = %X", original);

  /* Insert first digit in result */
  result |= original&mask;         /* put right 4 bits from original in result */
  
  /* Get second digit */
  original >>= 4;                    /* shift original right 4 places */
  result << 4;                      /* make room by shifting left 4 places */
  result |= original&mask;        /* put right 4 bits from original in result */

  /* Get third digit */
  original >>= 4;
  result << 4;
  result |= original&mask;        /* reminder - | sets and & tests */
  
  printf("\t result = %X\n", result); 
  return 0;
}

Originally Posted by KONI

You do it right 2 times and still wrong 2 other times:

Code:

  result <<= 4;

Thanks!

<<= <--- I'm going to make a computer game character outta that guy so I don't forget to check that again in a hurry next time. Thanks Koni. I was staring at that for 10 minutes at the word by word level.

Actually, my head gets a bit fuzzy when describing multiple hex characters in 1 unsigned int var. ie, mask 0xF looks like = 1111. I understand 0xF as it takes the maximum value 16 in binary.

But say for 0xABC... Would it look like this? ie, 3 characters appended. ie

A=10
B=11
C=12

= 10 || 11 || 12
= 1010 || 1011 || 1100
= .......101010111100

Would be ...........00000101010111100 be the final representation for 0xABC in a unsigned int?

so.... after reversing look like.....00000110010111010 for 0xCBA. bitwise shifting is pretty cool. I bet you could have fun with that!