An rvalue for an integral bit-field (9.6) can be converted to an rvalue of type int if int can represent all the values of the bit-field; otherwise, it can be converted to unsigned int if unsigned int can represent all the values of the bit-field.

According to my notes, however, for C++ on MS Visual Studio 2005 you get the following behavior: unsigned 8-bit field promotes to unsigned.

This may or may not comply with the standard, depending on how you interpret “can be”.

So, looking at the first example snippit, with my copy of gcc, I actually get that it’s promoted to a signed integer value, which is what I suspected would happen. Now, with g++ on the same machine, it gets promoted to an unsigned int, which I was not expecting. :>

I need to install VC++ real quick, as this pretty much runs counter to my understanding of C’s integral promotions.

The C standard does not really define how to handle bit-fields as
rvalues. If you are unfamiliar with rvalues, in the expression E1 = E2;
E1 is an "lvalue" and E2 is an "rvalue". As a result, implementations
have adopted different philosophies. The philosophy adopted by gcc is
"use the length of the type (e.g., int)" so that the following program:

struct {
    unsigned int a: 8;
} bits = {255};

int main(void) {

    printf("unsigned 8-bit field promotes to %s.\n",
        (bits.a << 24) < 0 ? "signed" : "unsigned");
}

When compiled using gcc bits.a is interpreted as an unsigned integer value.

The philosophy adopted by Microsoft Visual Studio is to "use the length
specified in the bit field", which in this case is 8.  When this eight-bit
value is used as an rvalue, it is subjected to integer promotions.  On
a typical system (such as IA-32) all of these values can be represented as
a signed int so the value is promoted to signed int.

This means, of course, that whether or not this value is treated as a
signed or unsigned value is implementation dependent.  This is one of many
implementation dependent aspects of bit-fields.

To find out how your compiler handles this, try running the following code.  The
results from running this under Microsoft Visual Studio 2005 are provided
as comments.

—————————————-
#include <stdio.h>
#if __cplusplus
#define LANG "C++"
#else
#define LANG "C"
#endif

struct {
    unsigned int a: 8;
} bits = {255};

struct {
    unsigned char a;
} bytes = {255};

unsigned char a = 255;

int main(void) {
  printf(LANG ", unsigned 8-bit field promotes to %s.\n",
    (bits.a << 24) < 0 ? "signed" : "unsigned");
  // C, unsigned 8-bit field promotes to unsigned.
  // C++, unsigned 8-bit field promotes to unsigned.
    

  printf(LANG ", unsigned 8-bit byte promotes to %s.\n",
    (bytes.a << 24) < 0 ? "signed" : "unsigned");
  // C, unsigned 8-bit byte promotes to signed.
  // C++, unsigned 8-bit byte promotes to signed.

  printf(LANG ", unsigned char variable promotes to %s.\n",
    (a << 24) < 0 ? "signed" : "unsigned");
  // C, unsigned char variable promotes to signed.
  // C++, unsigned char variable promotes to signed.

  printf(LANG ", unsigned char bitfield promotes to %s.\n",
    (charfield.a << 24) < 0 ? "signed" : "unsigned");
  // C, unsigned char bitfield promotes to signed.
  // C++, unsigned char bitfield promotes to signed.

  return 0; 
}