⽬录
1.
联合体类型的声明
2.
联合体的特点
3.
联合体⼤⼩的计算
4.
枚举类型的声明
5.
枚举类型的优点
6.
枚举类型的使⽤
1.
联合体
1.1
联合体类型的声明
像结构体⼀样，联合体也是由⼀个或者多个成员构成，这些成员可以不同的类型。
但是编译器只为最⼤的成员分配⾜够的内存空间。联合体的特点是所有成员共⽤同⼀块内存空间。所 以联合体也叫：
共⽤体
。
给联合体其中⼀个成员赋值，其他成员的值也跟着变化。
我们来看一个代码：
#include<stdio.h>
//联合类型的声明
union U
{
char C;
int i;
};
int main()
{
//联合变量的定义
union U u = { 0 };
//计算连个变量的大小
printf("%d\n", sizeof(u));
return 0;
}
结果为什么是4呢？
我们来看联合体的特点
1.2
联合体的特点
联合的成员是共⽤同⼀块内存空间的，这样⼀个联合变量的⼤⼩，⾄少是最⼤成员的⼤⼩（因为联合⾄少得有能⼒保存最⼤的那个成员）。
上面那个代码最大的成员是int占四个字节，所以上个代码输出结果是4.
我们再接着分析这个代码
#include<stdio.h>
//联合类型的声明
union U
{
char C;
int i;
};
int main()
{
//联合变量的定义
union U u = { 0 };
//计算连个变量的大小
printf("%d\n", sizeof(u));
printf("%p\n", &u);
printf("%p\n", &(u.i));
printf("%p\n", &(u.C));
return 0;
}
我们看到，联合体u的地址和C的地址i的地址是一样的。共用同一块空间。
看第二个代码
#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;
}
代码1输出的三个地址⼀模⼀样，代码2的输出，我们发现将i的第4个字节的内容修改为55了。
我们仔细分析就可以画出，un的内存布局图。
1.3
相同成员的结构体和联合体对⽐
我们再对⽐⼀下相同成员的结构体和联合体的内存布局情况。
#include <stdio.h>
struct S
{
char c;
int i;
};
int main()
{
struct S s = { 0 };
printf("%d\n",sizeof(struct S));
return 0;
}
我们再来看联合体的
#include <stdio.h>
union Un
{
char c;
int i;
};
int main()
{
union Un un = { 0 };
printf("%d\n", sizeof(union Un));
}
结构体在内存中的存储可看
1.4
联合体⼤⼩的计算
•
联合的⼤⼩⾄少是最⼤成员的
⼤⼩。
•
当最⼤成员⼤⼩不是最⼤对⻬数的整数倍的时候，就要对⻬到最⼤对⻬数的整数倍。
我们来看一个代码
#include<stdio.h>
union Un1
{
char c[5];//5 1 8 1
int i;//4 4 8 4
};
union Un2
{
short c[7];//14 2 8 2
int i;//4 4 8 4
};
int main()
{
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1));//8
printf("%d\n", sizeof(union Un2));//16
return 0;
}
union Un1
{
char c[5];//5 1 8 1
int i;//4 4 8 4
};
Un1中最大成员是c 占五个字节，但不是最大对齐数 4的倍数所以就要对齐到8.
union Un2
{
short c[7];//14 2 8 2
int i;//4 4 8 4
};
Un2中最大成员是c占14个字节，但不是最大对齐数4的字节，所以要对其到16.
所以联合体的大小，是其中最大成员的大小 (这句话是错误的)。
使⽤联合体是可以节省空间的，举例：
⽐如，我们要搞⼀个活动，要上线⼀个礼品兑换单，礼品兑换单中有三种商品：图书、杯⼦、衬衫。
每⼀种商品都有：库存量、价格、商品类型和商品类型相关的其他信息。
图书：书名、作者、⻚数
杯⼦：设计
衬衫：设计、可选颜⾊、可选尺⼨
那我们不耐⼼思考，直接写出⼀下结构：
#include <stdio.h>
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
联合的⼀个练习
写⼀个程序，判断当前机器是⼤端？还是⼩端？
我们先按寻常方法写一个判断程序
#include <stdio.h>
int main()
{
int a = 1;
if (*(char*)&a == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
vs是小端
#include <stdio.h>
int main()
{
union
{
char c;
int i;
}u;
u.i = 1;
if (u.c == 1)
printf("小端\n");
else
printf("大端\n");
return 0;
}我们也可以写成函数
#include <stdio.h>
int check_sys()
{
union
{
char c;
int i;
}u;
u.i = 1;
return u.c;
}
int main()
{
if (u.c == 1)
printf("小端\n");
else
printf("大端\n");
return 0;
}
2.
枚举类型
2.1
枚举类型的声明
枚举顾名思义就是⼀⼀列举。
把可能的取值⼀⼀列举。
枚举用enum表示
⽐如我们现实⽣活中：
⼀周的星期⼀到星期⽇是有限的7天，可以⼀⼀列举
性别有：男、⼥、保密，也可以⼀⼀列举
⽉份有12个⽉，也可以⼀⼀列举
三原⾊，也是可以意义列举
这些数据的表⽰就可以使⽤枚举了。
#include <stdio.h>
enum Day
{
Mon,//0
Tues,//1
Wed,//2
Thur,//3
Fri,//4
Sat,//5
Sun//6
};
enum Sex//性别
{
MALE,//0
FEMALE,//1
SECRET//2
};
int main()
{
printf("%d %d %d %d %d %d %d\n", Mon, Tues, Wed, Thur, Fri, Sat, Sun);
printf("%d %d %d\n", MALE, FEMALE, SECRET);
return 0;
}
以上定义的
enum Day
，
enum Sex
都是枚举类型。
{}中的内容是枚举类型的可能取值，也叫 枚举常量 。
这些可能取值都是有值的，默认从0开始，依次递增1，当然在声明枚举类型的时候也可以赋初值。
enum Day
{
//列出的是枚举类型的可能取值
//这些列出的可能取值被称为：枚举常量
Mon,//0
Tues,//1
Wed,//2
Thur,//3
Fri,
Sat,
Sun
};
enum Sex
{
MALE=4,//0
FEMALE=7,//1
SECRET=1//2
};
int main()
{
//printf("%d %d %d %d %d %d %d\n", Mon,Tues,Wed,Thur,Fri,Sat,Sun);
printf("%d %d %d\n", MALE, FEMALE, SECRET);
//MALE = 4;//ERR
enum Sex s = MALE;
enum Day d = Sun;
return 0;
2.2
枚举类型的优点
为什么使⽤枚举？
我们可以使⽤
#define
定义常量，为什么⾮要使⽤枚举？
枚举的优点：
1.
增加代码的可读性和可维护性
2.
和#define定义的标识符⽐较枚举有类型检查，更加严谨。
3.
便于调试，预处理阶段会删除
#define
定义的符号
4.
使⽤⽅便，⼀次可以定义多个常量
5.
枚举常量是遵循作⽤域规则的，枚举声明在函数内，只能在函数内使⽤
#include <stdio.h>
void menu()
{
printf("*********************\n");
printf("*** 1.add 2.sub ***\n");
printf("*** 3.mul 4.div ***\n");
printf("*** 0.exit ***\n");
printf("*********************\n");
}
enum Option
{
EXIT,
ADD,
SUB,
MUL,
DIV
};
//#define EXIT 0
//#define ADD 1
//#define SUB 2
//
//#define XOR 5
int main()
{
int input = 0;
do
{
menu();
printf("请选择:");
scanf("%d", &input);
switch (input)
{
case ADD:
break;
case MUL:
break;
default:
break;
}
} while (input);
return 0;
}
2.3
枚举类型的使⽤
#include <stdio.h>
enum Color//颜色
{
RED = 1,
GREEN = 2,
BLUE = 4
};
int main()
{
enum Color clr = GREEN;//使用枚举常量给枚举变量赋值
enum Color clr2 = 2;
printf("%d\n", sizeof(clr));//4
return 0;
}
那是否可以拿整数给枚举变量赋值呢？在C语⾔中是可以的，但是在C++是不⾏的，C++的类型检查⽐
较严格。
好的，我们自定义类型：联合体和枚举到此结束，我们下次见。
573
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
