Questions about C bitfields

Question

• Is bitfield a C concept or C++?

• Can it be used only within a structure? What are the other places we can use them?

• AFAIK, bitfields are special structure variables that occupy the memory only for specified no. of bits. It is useful in saving memory and nothing else. Am I correct?

I coded a small program to understand the usage of bitfields - But, I think it is not working as expected. I expect the size of the below structure to be 1+4+2 = 7 bytes (considering the size of unsigned int is 4 bytes on my machine), But to my surprise it turns out to be 12 bytes (4+4+4). Can anyone let me know why?

#include <stdio.h>

struct s{
unsigned int a:1;
unsigned int b;
unsigned int c:2;
};

int main()
{
  printf("sizeof struct s = %d bytes \n",sizeof(struct s));
  return 0;
}

OUTPUT:

sizeof struct s = 12 bytes 

Answer 1

Because a and c are not contiguous, they each reserve a full int's worth of memory space. If you move a and c together, the size of the struct becomes 8 bytes.

Moreover, you are telling the compiler that you want a to occupy only 1 bit, not 1 byte. So even though a and c next to each other should occupy only 3 bits total (still under a single byte), the combination of a and c still become word-aligned in memory on your 32-bit machine, hence occupying a full 4 bytes in addition to the int b.

Similarly, you would find that

struct s{
unsigned int b;
short s1;
short s2;
};

occupies 8 bytes, while

struct s{
short s1;
unsigned int b;
short s2;
};

occupies 12 bytes because in the latter case, the two shorts each sit in their own 32-bit alignment.

Answer 2

1) They originated in C, but are part of C++ too, unfortunately.

2) Yes, or within a class in C++.

3) As well as saving memory, they can be used for some forms of bit twiddling. However, both memory saving and twiddling are inherently implementation dependent - if you want to write portable software, avoid bit fields.

Answer 3

Its C.

Your comiler has rounded the memory allocation to 12 bytes for alignment purposes. Most computer memory syubsystems can't handle byte addressing.

Answer 4

Your program is working exactly as I'd expect. The compiler allocates adjacent bitfields into the same memory word, but yours are separated by a non-bitfield.

Move the bitfields next to each other and you'll probably get 8, which is the size of two ints on your machine. The bitfields would be packed into one int. This is compiler specific, however.

Bitfields are useful for saving space, but not much else.