联合在一些场景中很有用。 Union可以是非常低级的操作工具，比如为内核编写设备驱动程序。

其中一个例子是通过使用具有位域和浮点数的结构并集来解剖浮点数。我在浮点数中保存了一个数字，之后我可以通过该结构体访问浮点数的特定部分。该示例展示了如何使用联合来从不同角度查看数据。

#include <stdio.h>                                                                                                                                       

union foo {
    struct float_guts {
        unsigned int fraction : 23;
        unsigned int exponent : 8;
        unsigned int sign     : 1;
    } fg;
    float f;
};

void print_float(float f) {
    union foo ff;
    ff.f = f;
    printf("%f: %d 0x%X 0x%X\n", f, ff.fg.sign, ff.fg.exponent, ff.fg.fraction);

}

int main(){
    print_float(0.15625);
    return 0;
}

看看维基百科上的单精度描述。我使用了这个例子和其中的神奇数字0.15625。

联合还可用于实现具有多个备选项的代数数据类型。我在O'Sullivan, Stewart和Goerzen的《Real World Haskell》一书中找到了一个例子。 请查看受歧视的工会部分。

干杯!

结构分配其中所有元素的总大小。

一个联合只分配它最大的成员所需要的内存。

对于联合，您只应该使用其中一个元素，因为它们都存储在同一个位置。这在您想要存储可能是几种类型之一的内容时非常有用。另一方面，结构体的每个元素都有单独的内存位置，并且它们都可以一次使用。

为了给出它们使用的一个具体例子，我不久前正在研究一个Scheme解释器，我实际上是将Scheme数据类型覆盖到C数据类型上。这涉及到在一个结构体中存储一个指明值类型的枚举和一个用于存储该值的联合。

union foo {
  int a;   // can't use both a and b at once
  char b;
} foo;

struct bar {
  int a;   // can use both a and b simultaneously
  char b;
} bar;

union foo x;
x.a = 3; // OK
x.b = 'c'; // NO! this affects the value of x.a!

struct bar y;
y.a = 3; // OK
y.b = 'c'; // OK

编辑:如果你想知道将x.b设置为“c”会改变x.a的值，从技术上讲，这是未定义的。在大多数现代机器上，char是1字节，int是4字节，所以给x.b的值'c'也给x.a的第一个字节相同的值:

union foo x;
x.a = 3;
x.b = 'c';
printf("%i, %i\n", x.a, x.b);

打印

99, 99

为什么这两个值是一样的?因为int 3的最后3个字节都是0，所以它也被读为99。如果我们为x.a输入一个更大的数字，你会发现情况并非总是如此:

union foo x;
x.a = 387439;
x.b = 'c';
printf("%i, %i\n", x.a, x.b);

打印

387427, 99

为了更仔细地查看实际的内存值，让我们设置并打印十六进制的值:

union foo x;
x.a = 0xDEADBEEF;
x.b = 0x22;
printf("%x, %x\n", x.a, x.b);

打印

deadbe22, 22

您可以清楚地看到0x22覆盖了0xEF的位置。

BUT

在C语言中，int类型的字节顺序没有定义。这个程序在我的Mac上用0x22覆盖了0xEF，但是在其他平台上它会覆盖0xDE，因为组成int的字节的顺序颠倒了。因此，在编写程序时，永远不要依赖于覆盖联合中特定数据的行为，因为它是不可移植的。

有关字节排序的更多信息，请参阅endianness。

结构是不同数据类型的集合，其中可以驻留不同类型的数据 每一个都有自己的内存块。

当我们确定一次只使用其中一个变量，并且希望充分利用当前内存时，我们通常使用联合，因为它只获得一个等于最大类型的内存块。

struct emp
{
    char x; //1 byte
    float y; //4 byte
} e;

它获得的总内存:=>5字节。

union emp
{
    char x; //1 byte
    float y; //4 byte
} e;

它获得的总内存:4字节。

As you already state in your question, the main difference between union and struct is that union members overlay the memory of each other so that the sizeof of a union is the one , while struct members are laid out one after each other (with optional padding in between). Also an union is large enough to contain all its members, and have an alignment that fits all its members. So let's say int can only be stored at 2 byte addresses and is 2 bytes wide, and long can only be stored at 4 byte addresses and is 4 bytes long. The following union

union test {
    int a;
    long b;
}; 

could have a sizeof of 4, and an alignment requirement of 4. Both an union and a struct can have padding at the end, but not at their beginning. Writing to a struct changes only the value of the member written to. Writing to a member of an union will render the value of all other members invalid. You cannot access them if you haven't written to them before, otherwise the behavior is undefined. GCC provides as an extension that you can actually read from members of an union, even though you haven't written to them most recently. For an Operation System, it doesn't have to matter whether a user program writes to an union or to a structure. This actually is only an issue of the compiler.

union和struct的另一个重要属性是，它们允许指向它们的指针可以指向其任何成员的类型。因此，以下是有效的:

struct test {
    int a;
    double b;
} * some_test_pointer;

Some_test_pointer可以指向int*或double*。如果将一个test类型的地址转换为int*，它将指向它的第一个成员，实际上是a。工会也是如此。因此，因为联合将始终具有正确的对齐方式，您可以使用联合来使指向某些类型的指针有效:

union a {
    int a;
    double b;
};

这个联合实际上可以指向int型和double型:

union a * v = (union a*)some_int_pointer;
*some_int_pointer = 5;
v->a = 10;
return *some_int_pointer;    

实际上是有效的，正如C99标准所述:

对象的存储值只能由具有以下类型之一的左值表达式访问: 与对象的有效类型兼容的类型 .．. 在其成员中包含上述类型之一的聚合或联合类型

编译器不会优化出v->a = 10;因为它可能会影响*some_int_pointer的值(该函数将返回10而不是5)。

有什么好的例子可以说明结构体和联合体的区别吗?

下面是来自嵌入式系统应用的真实例子。它只使用联合，但它清楚地显示了联合的功能。

I2C通信协议的写函数在从传递给它的数组中检索数据时使用联合类型，用于数据存储。

union data
{
    uint32_t packet;
    uint8_t  packetbyte[4];
} txdata;

通过指针传递给write函数的数组包含一个字节大小的元素。在for循环中，这些字节分四个步骤逐一提取，并存储到txdata的各个元素中。packetbyte成员。

循环结束后，txdata。数据包包含4个字节的数据，这些数据被连续存储到txdata联合中。作为通过通信总线发送数据的最后一步，txdata。数据包被写入32位缓冲区，在被写入后，32位缓冲区启动写序列。然后通过txdata重置内容。在next for循环开始执行之前，Packet = 0。

通过这种方式，I2C主机可以重新传输32位数据包，直到发送通过的输入数据并终止写入功能。