自定义类型：联合体和枚举

目录：

1.1联合体的声明                                                                                                                                1.2.联合体的特点                                                                                                                                1.3.联合体的大小                                                                                                                                2.1枚举类型的声明                                                                                                                              2.2.枚举类型的优点                                                                                                                            2.3枚举类型的使用     

正文开始：

1.1联合体的声明：

跟结构体一样，联合体也是由很多成员组成的，它的成员可以是不同类型的变量。不一样的是编译器只给最大的成员分配足够的空间，并且所有成员共用这块空间，所以联合体也被称为共用体。                                                                                                                          

#include <stdio.h>
//联合类型的声明
union Un
{
 char c;
 int i;
};
int main()
{
 //联合变量的定义
 union Un un = {0};
 //计算连个变量的⼤⼩
printf("%d\n", sizeof(un));
return 0;

上面的代码结果是什么呢？结果是4，那为什么是4呢，接下来我们就来看看联合体的特点。

1.2.联合体的特点：

因为联合体的成员是共用一块内存的，那么空间大小起码能容纳最大成员，所以联合体的大小至少是最大的成员大小。

//代码1
#include <stdio.h>
//联合类型的声明
union Un
{
 char c;
 int i;
};
int main()
{
 //联合变量的定义
 union Un un = {0};
 // 下⾯输出的结果是⼀样的吗？
 printf("%p\n", &(un.i));
 printf("%p\n", &(un.c));
 printf("%p\n", &un);
 return 0;
}

结果是:
001AF85C
001AF85C
001AF85C

//代码2
#include <stdio.h>
//联合类型的声明
union Un
{
 char c;
 int i;
};
int main()
{
 //联合变量的定义
 union Un un = {0};
 un.i = 0x11223344;
 un.c = 0x55;
 printf("%x\n", un.i);
 return 0;
}
结果是:
11223355

代码1三个地址都相同，代码二存放44的地址的值替换成了55。             

相同成员的结构体和联合体比较：                                                       

1.3联合体的大小计算：        

1.联合体大小至少是最大成员的大小。                                                                                              2.如果最大成员大小不是最大对齐数的整数倍时，整体大小就要对齐到最大对齐数的整数倍。

#include <stdio.h>
union Un1
{
 char c[5];
 int i;
};
union Un2
{
 short c[7];
 int i;
};
int main()
{
 //下⾯输出的结果是什么？
 printf("%d\n", sizeof(union Un1));
 printf("%d\n", sizeof(union Un2));
 return 0;
}

这个结果大家可以算算，这里有必要说一下，数组我们先看单个元素，得到对齐数，再算数组的大小。所以char c[0]的对齐数是1，c[5]这个成员需要5个字节，然后存i，i是4个字节小于5字节，所以数组c[5]是大成员，整体大小是最大对齐数4的整数倍，所以sizeof(union Un1)=8。第二个跟这个没区别就不重复说了。

使用联合体是可以节省空间的，比如我们要弄一个活动，要上线一个礼品兑换单，礼品兑换单有三种商品：图书，杯子，衬衫。每个商品都有库存量，价格，商品类型，还有各自特殊的信息：        图书：书名，作者，页数                                                                                                                    杯子：设计                                                                                                                                          衬衫：设计，可选颜色，可选尺寸                                                                                                      我们可以直接写下它们的结构：                                                                                                         

struct gift_list
{
 //公共属性
 int stock_number;//库存量
 double price; //定价
 int item_type;//商品类型
 char title[20];//书名
 char author[20];//作者
 int num_pages;//⻚数
 
 char design[30];//设计
 int colors;//颜⾊
 int sizes;//尺⼨
};

上面的结构是结构平铺直叙的，很简单，但是用的内存比较多啊，每个创建的结构体变量都包括这些属性，比如图书，它肯定是把给颜色之类的属性空间给浪费掉的，所以我们用联合更好。所以我们就可以把共有属性单独写出来，其他特殊属性使用联合体，这样就可以介绍所需的内存空间了，节省了一些空间。

struct gift_list
{
 int stock_number;//库存量
 double price; //定价
 int item_type;//商品类型
 
 union {
 struct
 {
 char title[20];//书名
 char author[20];//作者
 int num_pages;//⻚数
 }book;
 struct
 {
 char design[30];//设计
 }mug;
 struct
 {
 char design[30];//设计
 int colors;//颜⾊
 int sizes;//尺⼨
 }shirt;
 }item;
};

2.1枚举变量的声明：

枚举的意思就是一一列举，比如我们的一个星期，可以从星期一列举到星期天，比如性别，列举男女等，说到这类举例的事物就可以用枚举了。

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};
enum Sex//性别
{
 MALE,
 FEMALE,
 SECRET
}；
enum Color//颜⾊
{
 RED,
 GREEN,
 BLUE
};

上面的enum Day，enum Sex，enum Color都是枚举类型，{}里面的数据都是它们的可能取值，也叫做枚举常量，并且这些可能取值都是有值的，按顺序从0开始赋值。当然在声明枚举类型的时候也可以赋初值。

enum Color//颜⾊
{
 RED=2,
 GREEN=4,
 BLUE=8
};

2.2枚举类型的优点：

其实我们这样看枚举好像也没啥特殊的是吧，用#define定义常量也可以达到这个目的，为什么要用枚举呢？以下给出几个优点：                                                                                                      1.增加代码的可读性，可维护性                                                                                                          2.和#define定义的标识符相比，枚举有类型检查，更加严谨                                                              3.便于调试，在预处理阶段会删除#define定义的符号                                                                        4.而且一下子可以定义很多常量，不然每个常量前面都要加#ddefine也挺麻烦的                              5.枚举常量是遵从作用域规则的，枚举声明在函数内，只能在函数内使用

2.3枚举类型的使用：

enum Color//颜⾊
 {
 RED=1,
 GREEN=2,
 BLUE=4
 };
 enum Color clr = GREEN;//使⽤枚举常量给枚举变量赋值

那我们能给枚举变量赋整数吗，在c语言里是可以的，但是在c++中这不被允许，因为c++的类型检查比较严格。

到这里，这篇文章就又到了尾声，我感觉联合体和枚举还挺简单的，内容容易消化，大家不用太花时间研究，希望能得到你的三连，拜拜。