Print Bits Part II: Coding Feedback Wanted

While @palacsint's code may work, it doesn't impress me as a model of clarity. I think I'd start from the fact that subtracting 1 from a number clears the least significant bit that was set, and sets all the less significant bits. If we start with a number that has only one bit set, that bit will be cleared, and all the less significant bits will be set. Based on that, getting a mask of N bits is pretty simple: take 1, shift it left N bits, and then subtract 1.

For example, consider creating a 5-bit mask in a 16-bit number:

0000 0000 0000 0001    // 1
0000 0000 0010 0000    // 1 << 5
0000 0000 0001 1111    // (1<<5)-1

Once we have that, we can shift it left p bits to get it to the right position, and xor with the input:

unsigned invert(unsigned x, unsigned p, unsigned n) { 
    unsigned mask = ((1u << n) - 1u) << p;
    return x ^ mask;
}

A couple minor points:

1. I've removed printing from invert -- IMO, printing the result should be separate.
2. This requires that n<size_of_int.

I think the printing can be simplified a bit as well. Although the "test for a multiple of 4" inside the loop does work, I think at least in this case a nested loop makes the intent clearer:

void print(unsigned x) { 
    static const int group_size = 4;
    int group, j;

    for (group = 0; group < size_of_int / group_size; group++) {
        for (j=0; j<group_size; j++, x >>= 1)
            printf("%c", (x & 1) + '0');
        printf(" ");
    }
}

Another possibility that might be worth considering would be a small lookup table to convert 4 bits at a time:

void print(unsigned x) { 
    static const int group_size = 4;
    // inverted order because you're printing the LSB first.
    static const char *outputs[] = {
        "0000", "1000", "0100", "1100", "0010", "1010", "0110", "1110", 
        "0001", "1001", "0101", "1101", "0011", "1011", "0111", "1111"
    };
    int group;

    for (group=0; group<size_of_int / group_size; group++, x >>= 4)
        printf("%s ", outputs[x & 0xf]);
}

Oh for the love of obsuscation... You should certainly not write this as a one-line goo of bit-wise operators. Use the invert function below. For convenience, I added a function for programmers who don't read binary code.

#include <stdint.h>
#include <stdio.h>

uint32_t invert (uint32_t number, uint32_t pos, uint32_t bits_n)
{
  uint32_t i;

  for(i=pos; i<pos+bits_n; i++)
  {
    number ^= (1<<i);
  }

  return number;
}


void print_binary_because_I_dont_understand_hex (uint32_t number)
{
  uint32_t i;

  for(i=32; i!=0; --i)
  {
    if( number & (1<<(i-1)) )
    {
      printf("1");
    }
    else
    {
      printf("0");
    }
    if( ((i-1) % 4) == 0 )
    {
      printf(" ");
    }
  }
  printf("\n");
}

int main()
{
  uint32_t some_int = 0xFFFFAAAA;

  some_int = invert(some_int, 8, 16);

  printf("%X\n", some_int);
  print_binary_because_I_dont_understand_hex (some_int);

  getchar();
  return 0;
}