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

为了给出它们使用的一个具体例子，我不久前正在研究一个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。

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

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

从技术上讲，非指:

假设:椅子=记忆块，人=变量

结构:如果有3个人，他们可以坐在相应大小的椅子上。

工会:如果有3个人，只有一张椅子可以坐，所有人都需要在他们想坐的时候使用同一把椅子。

技术上讲是指:

下面提到的程序对结构和联合进行了深入研究。

struct MAIN_STRUCT
{
UINT64 bufferaddr;   
union {
    UINT32 data;
    struct INNER_STRUCT{
        UINT16 length;  
        UINT8 cso;  
        UINT8 cmd;  
           } flags;
     } data1;
};

MAIN_STRUCT size =sizeof(UINT64) for bufferaddr + sizeof(UNIT32) for union + 32 bit for padding(取决于处理器架构)= 128 bits。 对于结构，所有成员连续获取内存块。

Union获得一个最大大小成员的内存块(这里是32位)。 在联合内部还有一个结构体(INNER_STRUCT)，它的成员获得一个总大小为32位(16+8+8)的内存块。在联合中，可以访问INNER_STRUCT(32位)成员或data(32位)。

当我们需要对具有一组独立属性的事物进行建模时，建议使用结构;当一个实体具有多种形式且一次只能以一种形式存在时，建议使用联合。

让我们看看它们可以应用的两个地方

您需要存储和更新汽车的值。为了做到这一点，我们需要记录汽车的所有属性，如型号、里程、价格和燃料类型。这些值总是存在于一辆车中，它们不依赖于其他值。 因此，我们需要一种数据类型，它不仅存储所有属性，而且还确保它们的正确更新。这种类型的任务可以使用结构来完成。

struct car{
    char model[];
    int mileage;
    int price;
    char fuel_type[];
};

组织需要从大量客户那里收集您的数据以进行付款验证。现在，为了数据完整性和客户安全，一个组织被指示从一个人那里获得最少的详细信息。 这些详细信息可以是您的PAN号码或帐户号码或选民身份证。现在，因为我们需要收集这些细节中的任何一个，同时也要节省内存，我们可以在这里使用联合。它将只保存提供给它的单个值。

union verification_details{
    char account_number[10];
    char PAN[10];
    char voter_id[10];
};

我发现下面的文章解释得很好:结构和联合的区别

简单的回答是:结构体是一个记录结构体:结构体中的每个元素分配新的空间。一个结构体

struct foobarbazquux_t {
    int foo;
    long bar;
    double baz; 
    long double quux;
}

为每个实例在内存中分配至少(sizeof(int)+sizeof(long)+sizeof(double)+sizeof(long double))字节。(“至少”是因为架构对齐约束可能迫使编译器填充结构。)

另一方面，

union foobarbazquux_u {
    int foo;
    long bar;
    double baz; 
    long double quux;
}

分配一个内存块并给它四个别名。因此sizeof(union foobarbazquux_u)≥max((sizeof(int)，sizeof(long)，sizeof(double)，sizeof(long double))，同样有可能添加一些对齐。

联合在一些场景中很有用。 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》一书中找到了一个例子。 请查看受歧视的工会部分。

干杯!