文章目录

1. 联合体1. 1 联合体类型的声明1. 2 联合体的特点1. 3 相同成员的结构体和联合体对比1. 4 联合体大小的计算1. 5 联合体的练习

2. 枚举2. 1 枚举类型的声明2. 2 枚举类型的优点2. 3 枚举类型的使用2. 4 枚举类型的实际使用

1. 联合体

1. 1 联合体类型的声明

像结构体一样，联合体也是由一个或者多个成员构成，这些成员可以不同的类型。

但是编译器只为最大的成员分配足够的内存空间。联合体的特点是所有成员共用同一块内存空间。所以联合体也叫：共用体。

给联合体其中一个成员赋值，其他成员的值也跟着变化。

<code>#include <stdio.h>

//联合类型的声明

union Un

{ -- -->

char c;

int i;

};

int main()

{

//联合变量的定义

union Un un = { 0 };

//计算联合体变量的大小

printf("%zd\n", sizeof(un));

return 0;

}

输出结果：

1. 2 联合体的特点

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小(因为联合体至少得有能力保存最大的那个成员)。

来看两个代码领会一下：

代码一

<code>#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;

}

这三个输出应该是一样的，因为联合体的特点是所有成员共用同一块内存空间，既然是同一块空间，那自然也是同一块地址了。

代码二

<code>#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;

}

我们知道 int 类型的数据在内存中是以字节为单位逆向存储的(详见：数据在内存中的存储)，那么如图所示：

显然，当修改 <code>un.c 时，同时也会修改 un.i 的数据，所以 un.i 此时应该是：0x11223355。

1. 3 相同成员的结构体和联合体对比

我们再对比一下相同成员的结构体和联合体的内存布局情况。

<code>struct S

{ -- -->

char c;

int i;

};

struct S s = { 0 };

union Un

{

char c;

int i;

};

union Un un = { 0 };

如图所示：

1. 4 联合体大小的计算

联合的大小至少是最大成员的大小。当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。

来根据上面的规则计算一下：

<code>#include <stdio.h>

union Un1

{ -- -->

char c[5];

int i;

};

union Un2

{

short c[7];

int i;

};

int main()

{

//下面输出的结果是什么？

printf("%zd\n", sizeof(union Un1));

printf("%zd\n", sizeof(union Un2));

return 0;

}

Un1：首先联合体要有能力存下 char c [5] 这个变量，所以联合体大小是5，然后我们再来算对齐数，我们在结构体的时候就说过：

对齐数 = 编译器默认的一个对齐数 与 该成员变量大小的最大值的较小值。

VS 中默认的值为 8

Linux中 gcc 没有默认对齐数，对齐数就是成员自身的大小

所以这个联合体的对齐数很好计算，是 4，那么 5 后面的第一个 4 的倍数是 8，因此这个联合体的大小就是 8。

Un2 ：short c[7] 是最大的成员,大小是14，联合体的对齐数是4，所以这个联合体的大小是16。

使用联合体是可以节省空间的，举例：

我们要搞一个活动，要上线一个礼品兑换单，礼品兑换单中有三种商品：图书、杯子、衬衫。

每一种商品都有：库存量、价格、商品类型和商品类型相关的其他信息。

商品相关的其他信息各不相同：

图书:书名、作者、页数

杯子:设计

衬衫:设计、可选颜色、可选尺寸

那我们可以不假思索地写出这个结构体：

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;//尺寸

};

上述的结构其实设计的很简单，用起来也方便，但是结构的设计中包含了所有礼品的各种属性，这样使得结构体的大小就会偏大，比较浪费内存。因为对于礼品兑换单中的商品来说，只有部分属性信息是常用的。比如:

商品是图书，就不需要design、colors、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;

};

这个结构体的大小和所需空间最大的一种商品类型所需空间相同，比上面的结构体空间小了不少。

1. 5 联合体的练习

写一个程序，判断当前机器是大端还是小端。

实际上，这道题目我在数据存储这篇博客的2.3 中就已经讲解过，并且也使用了联合体求解，这里便不再赘述了。

int check_sys()

{

union

{

int i;

char c;

}un;

un.i = 1;

return un.c;//返回1是小端，返回0是大端

}

2. 枚举

2. 1 枚举类型的声明

枚举顾名思义就是一一列举。

把可能的取值一一列举。

比如我们现实生活中

一周的星期一到星期日是有限的7天，可以一一列举

性别有:男、女、保密，也可以一一列举

月份有12个月，也可以一一列举

三原色，也是可以一一列举

这些数据的表示就可以使用枚举了。

enum Day//星期

{

Mon,

Tues,

Wed,

Thur,

Fri,

Sat,

Sun

};

enum Sex//性别

{

MALE,

FEMALE,

SECRET

};

enum Color//颜⾊

{

RED,

GREEN,

BLUE

};

以上定义的 enum Day，enum Color ,enum Sex都是枚举类型。

{}中的内容是枚举类型的可能取值，也叫枚举常量。

这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。

比如在enum Color中，如果不赋初值，默认是这样的：

enum Color//颜⾊

{

RED = 0,

GREEN = 1,

BLUE = 2

};

但是也可以进行赋初值：

enum Color//颜色

{

RED = 2,

GREEN = 4,

BLUE = 8

};

除此之外，还可以对其中几项单独赋初值，比如：

enum Color//颜色

{

RED,

GREEN = 4,

BLUE

};

那么这个时候这三个枚举常量分别是多少呢？

实际上，如果是这样对某些常量赋初值的话，枚举类型的第一个常量仍然从0开始，依次递增1，直到遇见赋初值的常量，然后从这个赋了初始值的常量的值开始，再次依次递增1。

上面的枚举常量的值分别是：

enum Color//颜色

{

RED = 0,

GREEN = 4,

BLUE = 5

};

2. 2 枚举类型的优点

为什么使用枚举?

我们可以使用 #define 定义常量，为什么非要使用枚举?

枚举的优点:

增加代码的可读性和可维护性和#define定义的标识符相比枚举有类型检查，更加严谨。便于调试，预处理阶段会删除 #define 定义的符号使用方便，一次可以定义多个常量枚举常量是遵循作用域规则的，枚举声明在函数内，只能在函数内使用

总而言之，枚举相较于 #define 定义的常量使用起来更加严谨，方便，因此一般情况下更推荐使用枚举。

2. 3 枚举类型的使用

枚举常量再其定义域内是可以和 #define 定义的常量一样直接使用的，除此之外，枚举还有枚举变量，可以和其他类型的变量一样进行赋值等操作：

#include<stdio.h>

enum Color//颜色

{

RED = 1,

GREEN = 2,

BLUE = 4

};

int main()

{

enum Color clr = GREEN;//使用枚举常量给枚举变量赋值

enum Color clr2 = 2;//这样在C语言中是可以的，但在C++中，由于更严格的检查，这样是不行的

enum Color clr3 = 3;//使用 int 类型给枚举类型赋值可能会出现这样的情况，

//3并不是某个枚举常量的值，但并不会报错

printf("%d ", clr3);

return 0;

}

甚至还能将3打印出来，这显然不是我们使用枚举预期的结果，因此要避免这样赋值。

2. 4 枚举类型的实际使用

说了这么多，我们来试一下枚举类型实际上该怎么使用吧，在之前的博客中，我们写过很多次计算器，这是我们在指针中使用回调函数优化的计算器：

但是你有没有想过一个问题：在 <code>main 函数的 switch 中，为什么 case1 就是加法，而case2 就是减法？当然这是和菜单一一对应的，但这显然并不利于代码的可阅读性，如果这是一个非常复杂的项目，这样的代码是很难理解的，那么我们可以使用枚举来优化这个代码的可阅读性：

//使用回到函数改造后，再使用枚举提高代码可阅读性

#include <stdio.h>

int add(int a, int b)

{ -- -->

return a + b;

}

int sub(int a, int b)

{

return a - b;

}

int mul(int a, int b)

{

return a * b;

}

int div(int a, int b)

{

return a / b;

}

enum calc_num//这里设置一个枚举类型，注意顺序，或者可以赋初值，要和菜单中的数字保持一致

{

END,

ADD,

SUB,

MUL,

DIV

};

void calc(int(*pf)(int, int))//看一看这个函数，它的参数是一个函数指针，而且这个函数指针的

{ //类型恰好和上面的4个计算用的函数类型相同

int ret = 0;

int x, y;

printf("输入操作数：");

scanf("%d %d", &x, &y);

ret = pf(x, y);//调用 calc 函数，会调用传参过来的函数，这就是回调函数

printf("ret = %d\n", ret);

}

int main()

{

int input = 1;

do

{

printf("*************************\n");

printf("1:add 2:sub \n");

printf("3:mul 4:div \n");

printf("*************************\n");

printf("请选择：");

scanf("%d", &input);

switch (input)

{

case ADD://将case后的值都替换成枚举常量

calc(add);//这里调用 calc 函数实际上是是在通过 calc 函数调用其他的函数

break;

case SUB:

calc(sub);

break;

case MUL:

calc(mul);

break;

case DIV:

calc(div);

break;

case END: printf("退出程序\n");

break;

default:

printf("选择错误\n");

break;

}

} while (input);

return 0;

}

谢谢你的阅读，喜欢的话来个点赞收藏评论关注吧！