1.联合体

联合体的特点

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

联合体的关键字：union

结构体的关键字：struct

枚举的关键字：enum

但是编译器只为最⼤的成员分配⾜够的内存空间。联合体的特点是所有成员共⽤同⼀块内存空间。所

以联合体也叫：共⽤体。

//struct S

//{

// char c;

// int i;

//

//};

//union Un

//{

// char c;

// int i;

//};

//int main()

//{

// printf("%zd\n", sizeof(struct S));//8

// printf("%zd\n", sizeof(union Un));//4

//

// return 0;

//}

/*

但是编译器只为最⼤的成员分配⾜够的内存空间。

联合体的特点是所有成员共⽤同⼀块内存空间。所以联合体也叫：共⽤体。

联合体的特点是所有成员共⽤同⼀块内存空间,这样一个联合变量的大小，至少是最大成员的大小

（因为联合至少的有能力保存最大的那个成员）

那么为什么这里是4呢？

*/

//union Un

//{

// char c;

// int i;

//};

//int main()

//{

// union Un un = { 0 };

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

// printf("%p\n", &un);//007EFDD4

把un里面的c和i的地址都打印出来

// printf("%p\n", &(un.c));//007EFDD4

// printf("%p\n", &(un.i));//007EFDD4

// return 0;

//}

/*

取出的地址都是相同的

第一个字节是c，所有的4个字节都是i

所以我们发现i和c公用这4个字节的空间

所以联合体也叫共用体

我们可以发现，当我们用i的时候我们就不能用c

用c的时候就不能用i

因为改i的时候，c也改了

所以联合体成员在使用的时候，一次只能用一个成员，不能同时一起用

同一个时间只能用一个成员

对于结构体的话，c和i有各自的空间，但是对于联合体来说，成员共用空间

*/

union Un

{

char c;

int i;

};

int main()

{

union Un un = { 0 };

un.i = 0x11223344;

un.c = 0x55;

//经过调试我们不难发现随着c的改变，i也被改变了

return 0;

}

联合体的特点是所有成员共⽤同⼀块内存空间。所以联合体也叫：共⽤体。

联合体大小的计算

联合的大小至少是最大成员的大小。

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

//union Un

//{

// char arr[5];//对齐数是1

// //这个数组放在这里，跟放5个char类型是一样的

//

// int i;//对齐数是4

//};

//int main()

//{

// printf("%d\n", sizeof(union Un));//8

// return 0;

//}

/*

计算出的是8，所以我们得知联合体的大小不一定是最大成员的大小

联合体的大小至少是最大成员大大小

这个联合体最大对齐数是4

那么联合体的总大小一定要是4的倍数

这个联合体最大成员的大小是这个数组，大小是5，就是相当于5个char类型

但是5不是4的倍数，所以后面还要浪费3个字节，对齐8，所以最终的大小是8个字节

所以联合体也是存在内存空间的对齐的

*/

//练习计算联合体大小

union Un

{

short arr[7];//对齐数是1

//这个数组放在这里，跟放5个char类型是一样的

int i;//对齐数是4

};

int main()

{

printf("%d\n", sizeof(union Un));//16

return 0;

}

/*

因为shourt类型是2个字节，那么7个short就是14个字节了

short arr的对齐数是按照2来算的

i的对齐数是4，那么最大对齐数是4

那么联合体的大小必须是4的倍数

虽然说联合体很节省空间，但是也不是那么很绝对的节省空间

*/

联合体的运用

/*

图书：库存量、价格、商品类型、书名、作者、⻚数

杯⼦：商品类型、价格、库存量设计、

衬衫：设计、可选颜⾊、可选尺⼨、库存量、价格、商品类型

*/

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

};

//将我们每次就只用一个的东西拎出来放到联合体里面

//我们只用开辟一块空间，就能将所有东西存进去

//每次只取一样东西

//我们这个union没有写名字，写成匿名，因为这些成员我们每次用的时候只用一次

联合体的练习

union Un

{

char c;//第一个字节

int i;

};

int main()

{

union Un un = {0};

un.i = 1;

if (un.c == 1)

{

printf("小端\n");

}

else

{

printf("大端\n");

}

return 0;

}

2.枚举类型

枚举类型的声明

枚举顾名思义就是一一列举的意思

就是将可能的值一一列举出来

我们可以声明枚举类型

枚举的关键字是enum

//struct A

//{

// int _a : 2;

// int _b : 5;

// int _c : 10;

// int _d : 30;

//};

//int main()

//{

// struct A sa = { 0 };

// //scanf("%d", &sa._b);//这是错误的

//

// //正确的⽰范

// int b = 0;

// scanf("%d", &b);

// sa._b = b;//直接进行赋值

// return 0;

//}

enum Day//星期

{

Mon,

Tues,

Wed,

Thur,

Fri,

Sat,

Sun

};

enum Sex//姓名

{

//该枚举类型的三种取值

//都是常量，被称为枚举常量

MALE=2,

FEMALE=4,//我们这里是给常量一个初始值，到后面就无法进行更改了

SECRET=8

};

int main()

{

//我们给枚举变量赋值的都是它的可能取值

/*enum Sex sex1 = MALE;

enum Sex sex2 = FEMALE;*/

printf("%d\n", MALE);//0

printf("%d\n", FEMALE);//1

printf("%d\n", SECRET);//2

/*

打印出来的值是0 1 2

因为枚举常量的值默认是从0开始的，一次递增往下走，涨1

*/

//如果我们希望这个值是我们期望的，我们可以在枚举类型中进行更改

//假如我们仅仅只改变了第一个值为2

//那么剩下两个值就是3 4

//如果第1个值不赋值，第二个值赋值为8，那么打印出来的就是0 8 9

//从我们设置的值进行递增，第一个值不设置的话默认就是0

return 0;

}

枚举类型的优点

那么我们为什么使用枚举呢？

为什么使⽤枚举？

我们可以使⽤ #define 定义常量，为什么⾮要使⽤枚举？

枚举的优点：

增加代码的可读性和可维护性

和#define定义的标识符⽐较枚举有类型检查，更加严谨。

便于调试，预处理阶段会删除 #define 定义的符号

使⽤⽅便，⼀次可以定义多个常量

枚举常量是遵循作⽤域规则的，枚举声明在函数内，只能在函数内使⽤

enum Sex//姓名

{

MALE=2,

FEMALE=4,

SECRET=8

};

int main()

{

enum Sex sex1 = MALE;//因为MALE的类型是enum Sex类型的，所以这么进行赋值是对的

//enum Sex sex1 = 3;这么赋值就是错的,因为3的类型是整型，但是赋值的前面的枚举类型的

//因为类型是不一样的，所以我们不能进行赋值

return 0;

}

define定义的话是全局的定义的

枚举类型的使用

enum Color//颜⾊

{

RED=1,

GREEN=2,

BLUE=4

};

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

//写一个计算器---完成整数的加法、减法、乘法

enum Option

{

EXIT,//默认的值是0

ADD=1,//值表达的是1

SUB,

MULL,

DIV

};

int Add(int x, int y)

{

return x + y;

}

int Sub(int x, int y)

{

return x - y;

}

int Mull(int x, int y)

{

return x * y;

}

int Div(int x, int y)

{

return x / y;

}

void menu()//菜单

{

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

printf("**********1. add 2. sub*******\n");

printf("**********3. mull 4. div*******\n");

printf("********* 0. exit **********\n");

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

}

int main()

{

int input = 0,ret=0;

int x, y;

do

{

menu();

printf("请选择一个算法");

scanf("%d", &input);

switch (input)

{

case ADD://这么写的话，ADD的值还是表达的1

printf("请输入两个数");

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

ret=Add(x,y);

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

break;

case SUB://对于这种我们想写什么就写什么case ADD都是可以的:

//我们是可以不用安排这个顺序的

printf("请输入两个数");

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

ret = Sub(x, y);

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

break;

case MULL:

printf("请输入两个数");

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

ret= Mull(x, y);

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

break;

case DIV:

printf("请输入两个数");

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

ret = Div(x, y);

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

break;

case 0:

printf("退出\n");

break;

default:

printf("选择错误，重新选择\n");

break;

}

} while (input);

return 0;

}