Reading/Writing bits in memory

Let's say I'm given a void* memory address and I need to print the bits located in this memory address. How can I do this?

In my processor memory addresses are 32bits as are memory values, also int are 32 bits. So I thought of doing this:

unsigned int value = *memory_address;

and then by simple arithmetic (some mod and div operations) to get the bits of the value saved in memory_address.

For example value mod 2 will give last bit of this value and so on. But from what I can tell (I was expecting different bits) it doesn't work. Any ideas why?

Also, is anyone aware of ready C source code that "does"开发者_C百科 such this, reads/writes bits from memory?

Shift the value by one for each bit and or it with 1

unsigned int value = *((unsigned int*)memory_address);
for( int i = 0; i < 32; i++)
{
    printf("%d ", value >> i & 1);
}

You can also do it with math operators. You have to get the bit value (2 to the power of the bit index) and substract that value at each iteration to make sure the modulo doesn't return values that we seen before:

for( int i = 0; i < 32; i++)
{ 
    int bit_value = (int)pow(2,i + 1);
    int num_bit_value = value % bit_value; 
    printf("%d ", num_bit_value ? 1 : 0  );
    value -= num_bit_value;
}

int main() {

  int a = 0xFFFF;

  void * v = &a; // v points to a

  int * aPtr = (int *) v; // aPtr also points to a

  int b = *aPtr; // b gets the value aPtr points to, aka a or 0xFFFF

  int aBit = (b >> 3) & 1; // aBit now contains bit 3 of the original a value

  // toggle the bit
  if (aBit) {
    b &= ~(1 << 3); // set bit 3 to 0
  } else {
    b |= (1 << 3); // set bit 3 to 1
  }

  *aPtr = b; // update original a
}

I found it easier to think of the memory as a continuous string of characters rather than a void pointer. This way you can address as many bits as you want.

Here is how I have done it.

unsigned char
get_bit(char *array, int bit)
{
        int byte, k;
        byte = bit/8;
        k = 7 - bit % 8;
        return array[byte] & (1 << k);
}


void
set_bit(char *array, int bit, unsigned char value)
{
        int byte, k;
        byte = bit/8;
        k = 7 - bit % 8;
        if (value)
                array[byte] |= (1 << k);
        else
                array[byte] &= ~(1 << k);
}

How about:

bool isBit4Set = ((*someAddress) & 0x8 != 0);
(*someAddress) |= 0x8;   // Set bit 4

Generic solution for printing bytes and bits.

void dump_data(const void *object, size_t size)
{
  int i;
  printf("[ \n");
  for(i = 0; i < size; i++)
  {
    if (i%4 ==0)
    {
      printf("@%02X",&((const unsigned char *) object)[i]);
      printf("[ ");
    }
    printf("%02x ", ((const unsigned char *) object)[i] & 0xff);
    if ((i+1)%4 == 0)
      printf("]\n");
  }
  printf("]\n");

  printf("BINARY FORMAT\n");
  for (i = 0; i < size; i++)
  {
    printf("@%02X",&((const unsigned char *) object)[i]);
    printf("[ ");
    unsigned char value = (((unsigned char*)object)[i]);
    for(int j=0; j<8; j++)
      printf("%d ", (value & (0x80 >> j)) ? 1 : 0); // right shifting the value will print bits in reverse.
    printf("]\n");
  }
}

bool getBit(void* data,int bit){ return ((*((int*)data)) & 1<<bit); }

void setBit(void* data,int bit,bool set){ if(set){ (*((int*)data)) |= 1<<bit; }else{ (*((int*)data)) &= ~(1<<bit);  } }

for simple usage