CODEWITHSUNDEEP
cbit-fields
aks
aks

Reputation: 4805

Questions about C bitfields

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

Upvotes: 8

Views: 1762

Answers (5)

Parshuram Thombare
Parshuram Thombare

Reputation: 21

Bitfields are widely used in firmware to map different fields in registers. This save a lot of manual bitwise operations which would have been necessary to read / write fields without it. One disadvantage is you can't take address of bitfields.

Upvotes: 0

anon
anon

Reputation:

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.

Upvotes: 8

Richard Pennington
Richard Pennington

Reputation: 19965

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.

Upvotes: 0

Remy
Remy

Reputation: 329

Its C.

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

Upvotes: 0

Mark Rushakoff
Mark Rushakoff

Reputation: 258128

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.

Upvotes: 12

Related Questions