bit-fields

Is it possible in C to get the size of the following structure to be 2? #include <stdio.h> struct union_struct { char foo; char bar : 2; union { char foobar1 : 6; char foobar2 : 6; }; }; int main(void) { printf("size of union struct: %d\n", sizeof(struct union_struct)); return 0; } output, compiled with gcc: size of union struct: 3 If you are relying on implementation defined behavior, then yes, but you have to organize it a bit differently: #ifdef UNNAMED_BITFIELDS_ARE_WELL_DEFINED #define ANON #else #define ANON3(X) anonymous__## X ##__ #define ANON2(X) ANON3(X) #define ANON ANON2(__LINE__)

I've been doing some reading about bitfields in C, how the C standard doesn't enforce any particular ordering of the fields in a machine word, and so on. I hope this question appropriately fits the format of SO. My question is whether my struct (definition following) will actually perform in the way I expect. Here's the definition I came up with, and then I'll discuss what I want: typedef enum { STATE_ONE, STATE_TWO, STATE_THREE, STATE_FOUR } __attribute__ ((packed)) State; typedef struct MyStruct { // One of State enum (maximum of 4 states). unsigned state : 2; // Remaining 30 bits are used

On this link I came across http://lxr.linux.no/#linux+v2.6.36/include/linux/pci.h#L299 integer declaration unsigned int is_added:1; I have made C programs and declared integers in them but in the above I see use of : What sort of syntax is that? I think you have come across a bit-field :) It's part of a struct , which means that it indicates that the field should only use a certain number of bits instead of an entire byte or more. This is bit field declaration in an array. The number post ":" denotes number of bits to allocate to this particular field of the structure. Although you need to be

Question says it all. If I have this for a 96-bit field: uint32_t flags[3]; //(thanks @jalf!) How do I best go about accessing this, given that my subfields therein may lie over the 32-bit boundaries (eg. a field that runs from bit 29 to 35)? I need my accesses to be as fast as possible, so I'd rather not iterate over them as 32-bit elements of an array. [This answer is valid for C (and by extension, for C++ as well).] The platform-independent way is to apply bit-masks and bit-shifts as appropriate. So to get your field from 29 to 35 (inclusive): (flags[1] & 0xF) << 3 | (flags[0] & 0xE0000000)

This is about ANSI-C (C90). This is what I know: I can directly tell the compiler how many bits I want for a specific variable. If I want 1 bit which can have the values zero or one. or 2 bits for the values 0,1,2,3, and so on...; I'm familiar with the syntax. I have problem concerning bitfields: I want to define a SET structure. It can have maximum 1024 elements (it can have less, but the maximum is 1024 elements). The domain of the set is from 1 to 1024. So an element could have any value 1-1024. I'm trying to create a structure for a SET, and it must be efficient as possible for the memory