前言：

 相信大家都已经学过struct结构了，union联合是一个跟它很像的玩意

当然说实话，平常还是很少很少用到的，不过，考试那是一定会考你的；

                     

如果我们用struct想整合三个不同类型的数据 是这样写的：

struct{
	char c;
	short s;
	long long ll;
}s; 

如果我们用联合union 是这样写的：

union{
    char c;
    short s;
    long long ll;
}u;

看上去好像差不多，那它们的区别在哪里？

差异：

首先是内存上：

我们用sizeof打印一下两个玩意的大小

  printf("sizeof s:%d\n",sizeof(s));
	printf("sizeof u:%d\n",sizeof(u));

得到结果如下：

 这时候就有人要问了，我struct结构类型里面一个char1字节，short2字节，long long8字节加起来不是11吗 还有这个联合union怎么是8？

我们一步步来，先把它们的成员内存地址打出来看看

printf("&s.c %d \n", &s.c);
printf("&s.s %d \n", &s.s);
printf("&s.ll %d \n\n", &s.ll);
printf("&u.c %d \n", &u.c);
printf("&u.s %d \n", &u.s);
printf("&u.ll %d \n", &u.ll);

结果如下：

 先说明struct类型，画一张图来理解一下内存分布

&s.c 4223024 char类型首地址 
&s.s 4223026 short类型首地址 
&s.ll 4223032 longlong类型首地址 

蓝色是char类型 绿色是short类型 红色是longlong类型

根据地址，我们画出了结构 s 各个成员的内存排布情况。 char 与 short 只留空了一个字节，
而 short 与 long long 之间留空了4个字节。因此struct这里占了16字节
这种现象被称为内存对齐，虽然会浪费一些内存空间，对齐后的数据能够被更快的访问。
内存对齐有一套规则，这里我们并不展开讨论结构中的成员是如何对齐的了。我们接着往下看，看看联合union中的成员的内存排布情况。

联合 u 的成员 c 的首地址为4223040
联合 u 的成员 s 的首地址为4223040
联合 u 的成员 ll 的首地址为4223040。
联合中成员的首地址是重叠的。

它们的内存分布如下图：

同样蓝色是char类型 绿色是short类型 红色是longlong类型

 我们发现 ，没错，联合中的成员首地址是重叠的，这意味着联合的大小为联合中最大成员的大小

所以union的大小就等于其最大成员的大小，也就是long long 8字节

画重点强调 学校选择题会考的：union的大小就等于其最大成员的大小

联合性质

既然各成员之间有重叠的部分，那么存储一个成员后，将覆盖掉其他成员的数据。

	u.c =123;
printf("u.c %d \n", u.c);
    u.s=0;
printf("u.c %d \n", u.c);

输出为：

u.c 123
u.c 0

由于共用了一段内存，存储一个成员后，将覆盖其他成员的数据。所以，联合也被翻译为共用。

那么联合有什么用 数据都被破坏了（好吧的确很少用） 但是联合有其独特的优势

联合的应用

这里举个栗子(看不懂多体会体会 不过选择题一般只会考一些基本性质）

和struct对比一下 方便理解

有一种信息，它只有3种形态：
1. 整数
2. 浮点数
3. 字符串

并且一次只能出现一种形态

如果用结构 struct 来存储这种信息。而这个信息可能是整型，可能是浮点数，也可能是字符串。那
么，需要准备三个不同类型的成员。由于一次只会出现一种形态，所以，每次仅用一个成员，另外两个
留空。
另外，需要一个整型的 type 成员来标记这一次是什么类型。例如：1代表整型，2代表浮点，3代表字符
串。

struct message{
int type;
int n;
float f;
char *str;
};

拿到消息后，根据消息的 type 使用不同的方式处理消息。
 

void printMsg(struct message msg)
{
switch (msg.type)
{
case 1:
printf("%d\n", msg.n);
break;
case 2:
printf("%f\n", msg.f);
break;
case 3:
printf("%s\n", msg.str);
break;
}
}

完整代码如下：

#include <stdio.h>
struct message
{
int type;
int n;
float f;
char *str;
};
void printMsg(struct message msg)
{
switch (msg.type)
{
case 1:
printf("%d\n", msg.n);
break;
case 2:
printf("%f\n", msg.f);
break;
case 3:
printf("%s\n", msg.str);
break;
}
}
int main()
{
struct message msg[3];
// 第一个信息为整型，type为1
msg[0].type = 1;
msg[0].n = 123;
// 第二个信息为浮点型，type为2
msg[1].type = 2;
msg[1].f = 3.1415926;
// 第三个信息为字符串，type为3
msg[2].type = 3;
msg[2].str = "HelloWorld";
for (int i = 0; i < 3; i++)
{
printMsg(msg[i]);
}
return 0;
}

显然，每一个信息中，都有两个成员变量是空置的。但是，如果使用联合 union 就能将这三个不同类 型的成员所占空间合而为一

#include <stdio.h>
struct message
{
int type;
union {
int n;
float f;
char *str;
}u;
};

当然， type 成员是一定需要有的，否则无法判断是什么类型的信息。所以，它不能合并进入 union 。
拿到消息后，同样也需要根据消息的 type 使用不同的方式处理。确定 type 后，再从 msg 中找
到 union 成员 u ，再根据类型，选择对应的成员进行处理。

void printMsg(struct message msg)
{
switch (msg.type)
{
case 1:
printf("%d\n", msg.u.n);
break;
case 2:
printf("%f\n", msg.u.f);
break;
case 3:
printf("%s\n", msg.u.str);
break;
}
}
int main()
{
struct message msg[3];
// 第一个信息为整型，type为1
msg[0].type = 1;
msg[0].u.n = 123;
// 第二个信息为浮点型，type为2
msg[1].type = 2;
msg[1].u.f = 3.14159;
// 第三个信息为字符串，type为3
msg[2].type = 3;
msg[2].u.str = "HelloWorld";
for (int i = 0; i < 3; i++)
{
printMsg(msg[i]);
}
return 0;
}

另外，还有一种匿名嵌套的写法。嵌套的 union 中没必要写明成员名 u 。在其后的使用中， union 中的成员当做 message 的成员一样处理。

struct message
{
int type;
union {
int n;
float f;
char *str;
}; // 这里省去成员名u，作为匿名嵌套成员。
};
void printMsg(struct message msg)
{
switch (msg.type)
{
case 1:
printf("%d\n", msg.n); // msg.u.n省略为msg.n
break;
case 2:
printf("%f\n", msg.f); // msg.u.f省略为msg.f
break;
case 3:
printf("%s\n", msg.str); // msg.u.str省略为msg.str
break;
}
}