C编程中的结构和联合

Question

I am unsure what the Printf statement for Status would print ?, I am guessing it is compiler dependent, can anyone explain what this set Status at the end would print ?

#include <stdio.h>
#include <string.h>

typedef union {
 struct {
   unsigned char colour;
   struct {
     unsigned char contrast :1;
     unsigned char density :3;
     unsigned char depth :1;
     unsigned char brightness :1;
     unsigned char saturation :1;
     unsigned char channel :1;
 } bits;
} XStruct;


  unsigned short status;
} XUnion;


void main(void) {
 XUnion yunion;

 memset(&yunion, 0x00, sizeof(yunion));

 yunion.XStruct.contrast = 0xAE;
 yunion.XStruct.bits.density = 0x01;
 yunion.XStruct.bits.depth = 0x02;
 yunion.XStruct.bits.saturation = 0x01;

 printf("Status: %d", yunion.status);
}

Answer 1

On a system with 8-bit chars (octets) and little endian byte orderings (like all x86/x64 processors) the expected output is 17838, or in hexadecimal 45AE .

On a system with 8-bit chars (octets) and big endian byte orderings the expected output is 44613, or in hexadecimal AE45 .

On systems with differently sized chars the output is harder to predict, but luckily those are rare, if not non-existent, nowadays.

Explanation: the inner struct has a clearly defined ordering, following up 2 entire octets after eachother. Hence it is clear that after your code these will contain, in order, the hexadecimal values AE and 45 . They are mapped onto a short as a union, essentially meaning a 'reintepretation' of the same in-memory data as another type, and a short is defined by standard as a 2-byte value, which means endianness comes into play if you read it out that way - is the first or the last byte the most significant? Hence the predicted results above vary only on that part of the system's architecture.

Answer 2

A Union can have variables with multiple data types, but you can assign values to only one of them.

What happens when you assign value to one variable, and print the another?

You can think of a Union as a memory block, starting at address 0, for ease of calcualtion. The size of this memory block, is the size of the largest data type used in this Union. In your case, it would be the struct .

So when you assign values to variables in the Union, you're "putting" values in this block. And when you print any of those members , it'll print the contents of the block from the start of the Union upto the size of the data type of the member you printed.

In your case, you've printed the variable status . Now, on my system unsigned short uses 2 bytes of storage. So on my system, it prints the first two bytes of the Union after you've assigned those values. After assigning values like you did, the first two bytes of this memory block looks like this:

    0100 0101 1010 1110

So , when I print status on my machine, it prints 0x45ae or 17838 in decimal. Thus, the result would vary from system to system, based on the value of sizeof(unsigned short)

Play with that code, change the assigned values to notice the difference in output. That way you'd understand faster.

Update:

The ordering of the bit field, depends on the target platform's endianness. Check this out:

Big and Little Endian

and then, this:

How Endianness affects bitfield packing

With that in mind, here's the break up of your bitfield:

    1                 010    00     1       0
   line_current_on   flags1     battery_ok

That's the intuitive ordering (big endian). But my platform uses Little Endian representation, so my compiler looks at it as

    0      1           00    010          1
       battery_ok           flags1  line_current_on

which is the reverse. Same goes for your struct. Notice how the bitfield came before the Voltage member in memory. Little Endian.