Thread: i've got a problem i can't really comprehend

You mean like this?

Code:

#include <stdio.h>

void show_num_as_bin(unsigned int num, int startbit, int endbit)
{
  int bit;

  for(bit = endbit-1;bit >= startbit-1;bit--)
    printf("%d", num & (1 << bit) ? 1 : 0);
  printf("\n");
}

int main(void)
{
  unsigned int num = 0x7a348734;
  int groups[] = { 6, 10, 5, 5, 6 };
  int i, start = 1;

  show_num_as_bin(num, 1, 32);

  for(i = 0;i < 5;++i)
  {
    show_num_as_bin(num, start, start + groups[i] - 1);
    start += groups[i];
  }

  return 0;
}
itsme@itsme:~/C$ ./bit
01111010001101001000011100110100
110100
1000011100
10100
10001
011110
itsme@itsme:~/C$

Or you can do it like this where num & mask is actually a useful portion of the original number:

Code:

#include <stdio.h>

void show_num(unsigned int num)
{
  int bit;

  printf("0x%08X: ", num);
  for(bit = 31;bit >= 0;bit--)
    printf("%d", num & (1 << bit) ? 1 : 0);
  printf("\n");
}

int main(void)
{
  unsigned int num = 0x7a348734;
  int groups[] = { 6, 10, 5, 5, 6 };
  int i, j, mask, start = 0;

  show_num(num);
  printf("\n");

  for(i = 0;i < 5;++i)
  {
    mask = 0;
    for(j = 0;j < groups[i];++j)
      mask |= 1 << j;
    mask <<= start;

    show_num(num & mask);
    start += groups[i];
  }

  return 0;
}
itsme@itsme:~/C$ ./bit
0x7A348734: 01111010001101001000011100110100

0x00000034: 00000000000000000000000000110100
0x00008700: 00000000000000001000011100000000
0x00140000: 00000000000101000000000000000000
0x02200000: 00000010001000000000000000000000
0x78000000: 01111000000000000000000000000000
itsme@itsme:~/C$

And finally, the exact way you showed you wanted it:

Code:

#include <stdio.h>

void show_num_as_bin(unsigned int num, int startbit, int endbit)
{
  int bit;

  for(bit = endbit-1;bit >= startbit-1;bit--)
    printf("%d", num & (1 << bit) ? 1 : 0);
}

int main(void)
{
  unsigned int num = 0x7a348734;
  int groups[] = { 6, 10, 5, 5, 6 };
  int i, start = 32;

  show_num_as_bin(num, 1, 32);
  printf("\n\n");

  for(i = 4;i >= 0;--i)
  {
    show_num_as_bin(num, start - groups[i] + 1, start);
    start -= groups[i];
    printf(" ");
  }
  printf("\n");

  return 0;
}
itsme@itsme:~/C$ ./bit
01111010001101001000011100110100

011110 10001 10100 1000011100 110100
itsme@itsme:~/C$

Why is it everyone feels the need to do everything for people? What ever happened to pointing the way and helping with errors?

Quzah.

Maybe I should have explained my example in your other thread.

If you have a hex number - 7a348734
each separate digit is made up of 4 bits (half a byte). I believe its called a nibble?

Since your wanting each digit separately you can mask.

Going from right to left (starting at bit 0) you can get just ththose 4 bits like so:

Code:

//our hex number
int num = 0x7a348734

//you could create an array to hold each nibble
unsigned char nibble[8];

//going from right to left
nibble[0] = num & 0x0000000F;  // now holds 4 by itself
nibble[1] = (num & 0x000000F0) >> 4; // now holds 3 by itself

now the way & works is it compares each bit of the two variables and "returns" 1 if both bits are 1, 0 otherwise

so if you have the hex number 7ab3 (random hex number)

that would be 0111101010110011
then if you and it with 0x000F

Code:

 0111101010110011
&0000000000001111
---------------------------
 0000000000000011

and 0000000000000011 = 3

now as you go on through the number you will need to shift the bits so that the target number is all the way to the right. (so youd shift an extra 4 bits each digit).

I hope this has helped you understand and not confused you further.

EDIT:
I just noticed that you want them in different bit length. But the concepts still apply. By the way, why exactly do you need them in these different lengths?