When a single-bit bitfield that was formed from an enum
is promoted/cast into an integer, does ANSI C say anything
If it is cast, it becomes whatever it is cast to. That has nothing to
do with implicit conversions.
about whether that integer should be signed or unsigned?
SGI IRIX cc thinks it is an unsigned integer, so I
see a +1 if the bit is set. Microsoft VC++ thinks it's
signed, so I see -1 if the bit is set.
A single bit bit-field must promote to a signed int. In fact, any
bit-field with no more than 15 bits must promote to signed int, even
if it is defined as an unsigned int bit-field.
========
6.3.1.1 Para 2 & 3:
2. The following may be used in an expression wherever an int or
unsigned int may be used:
— An object or expression with an integer type whose integer
conversion rank is less than the rank of int and unsigned int.
— A bit-field of type _Bool, int, signed int, or unsigned int.
If an int can represent all values of the original type, the value is
converted to an int; otherwise, it is converted to an unsigned int.
These are called the integer promotions. All other types are
unchanged by the integer promotions.
3. The integer promotions preserve value including sign. As discussed
earlier, whether a ‘‘plain’’ char is treated as signed is
implementation-defined.
========
Since the only possible values of a 1 bit unsigned int bit-field are 0
and -1, so a signed int can represent all possible values. The only
possible values of a 1 bit unsigned int bit-field are 0 and +1, and a
signed int can represent all possible values. So a single bit
bit-field defined as int must promote to a signed int in an
expression, regardless of whether the implementation considers the
bit-field to be signed or unsigned int.
Ex.
typedef enum {
ZERO = 0,
ONE = 1
} test_enum_t;
typedef struct {
test_enum_t bitfield : 1;
} enum_struct_t;
int main( void )
{
enum_struct_t enum_struct;
enum_struct.bitfield = 1; /* bit is set */
if ( (test_num_t) enum_struct.bitfield == ONE ) {
^^^^^^^^^^^^
This is a cast, and it is meaningless. The value of the bit-field
will be converted to a test_num_t, which either is an int or will be
automatically promoted to an int by the rules I quoted above.
printf( "Bit is ONE\n" ); /* cast as unsigned int? */
There is no cast here. There is no such thing as an implicit cast in
C. A cast is an explicit conversion, which might or might not be an
acceptable automatic conversion without a cast.
}
else {
printf( "Bit is ZERO\n" ); /* cast as signed int? */
}
return 0;
}
You are confused, you are comparing the constants ONE and ZERO against
the value of your bit-field converted to a (signed) int.
What is confusing you is the fact that when a bit-field is defined as
"int", or a type such as an enumerated type, without specifying signed
int or unsigned int, it is up to the implementation to decide whether
to treat it as signed or unsigned. Exactly the same as whether
"plain" char is signed or unsigned.
Your compiler treats your unspecified bit-fields as unsigned, which
should be documented in its documentation. That unsigned bit-field
promotes to the signed int value of 1 in an expression.
If your compiler treated that bit-field as unsigned, your second
printf() statement would execute, but it would lie, because your
bit-field would convert to the int value -1.
Try:
printf("Bit is %d\n", enum_struct.bitfield);
Then try changing the type of the bit-field to, in turn, int, signed
int, unsigned int, and see what is output.
