Isn't that exactly what I suggested with the flags?

in principle, but like that you can access the single bits directly. this feature is quite neat because noone knows about it ;-).

@Joey: Wow, never heard about that. But this looks like just what I need, even without any #define s. One question remains, though...

Let's assume I have a struct and some boolean values within:

typedef struct {
unsigned int FLAG1 : 1;
unsigned int FLAG2 : 1;

...

}my_struct;


The var-type of th e flags is now "unsigned int". However, the ": 1;" statement tells the compiler to use just 1 Bit for that value, am I right so far? If so, does the ": 1;" statement kind of "override" the original space requirement of the var-type (here: unsigned int)?

in principle, yes. in principle it does not matter what integer type you use here, as long as you don't use char FLAG : 15, which is obviously nonsense, and of course the type is important for the underlying arithmetic used (unsigned). also note that the code generated out of this might be inefficient (it depends on the compiler used).

you can always use sizeof(my_struct) to check the memory usage of your struct.

I see. And about the efficiency-topic - since we're in the lite-C-forum here, I would like to use this with the standard-A7-commercial-compiler which comes with SED. Will it be able to handle it efficiently? Or should I rather use #define s? Does Lite-C itself even support bit-fields? (I suppose so, just to make sure)

On a web-page I read that "signed int flag1 :1;" will always have a value of either 0 or -1. However, the text didn't say anything about "unsigned int flag1 :1;"... May I run into problems here?

You have to use bit-fields as bit members are not supported by lite-C (AFAIK).

"Does Lite-C itself even support bit-fields?"
Yes. Probably you have already used them when setting and unsetting entity flags and so on.

i don't know if the compiler supports it. atm flags are set via set() or reset() which implies the define-stuff with one or several big flag integers.

the 0 and -1 thing is due to the way negative numbers are stored in computers, it is always something like from -n,-n+1,...,0,...,n-1 - there's always one more negative number than positive numbers. i guess when you use unsigned it will be 0 and 1.

what are bit members (@saturnus), if i may ask?

"what are bit members (@saturnus), if i may ask?"
I was referring to this syntax: "unsigned int flag: 1;" within a struct.
Just seemed appropriate to me. : )

However, this doesn't seem to compile in lite-C. And I think the unsigned modifier is ignored by lite-C, too.

that's weird, i thought lite-c was fully ansi-c compliant, but i may be mistaken here.

Would be interesting to know if there is a list of features which original C supports but lite-C does not... Up to now I also thought that lite-C can do anything and everything ordinary C can do.