自定义类型详解:结构体,枚举,联合
struct enum union
目录
前言
一、结构体
1.结构体类型的声明
2.结构的自引用
3.结构体变量的定义和初始化
4.结构体内存对齐
为什么存在内存对齐?
5.修改默认对齐数(vs)
6.结构体传参
6.结构体实现位段（位段的填充&可移植性）
位段的跨平台的问题
二、枚举
1.枚举类型的定义
2.枚举的优点
3.枚举的使用
三.联合(共用体)
1.联合类型的定义
2.联合的特点
3.联合大小的计算
总结
前言
结构体
1.结构体类型的声明
2.结构的自引用
3.结构体变量的定义和初始化
4.结构体内存对齐
5.结构体传参
6.结构体实现位段（位段的填充 & 可移植性）
枚举
1.枚举类型的定义
2.枚举的优点
3.枚举的使用
联合
1.联合类型的定义
2.联合的特点
3.联合大小的计算
一、结构体
结构体是C语言中一种重要的数据类型，该数据类型由一组称为成员（或称为域，或称为元素）的不同数据组成，其中每个成员可以具有不同的类型。 结构体通常用来表示类型不同但是又相关的若干数据。
1.结构体类型的声明
struct tag//类型声明
{
member-list;//成员变量
}variable-list;//结构体变量例如:描述一个学生
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}; //分号不能丢一个学生是由名字,年龄性别,学号等元素构成.
结构体的匿名声明
//匿名结构体类型
struct
{
int a;
char b;
float c;
}x;2.结构的自引用
正确引用
struct Node
{
int data;
struct Node* next;
};错误引用
struct Node
{
int data;
struct Node next;
};这个错误的原因是无法找到截至位置,即递归错误.如果可以，那sizeof(struct Node)是多少？显然是算不出来的.无穷大.
3.结构体变量的定义和初始化
struct Point
{
int x;
int y; }p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
};
struct Stu s = {"zhangsan", 20};//初始化
struct Node
{
int data;
struct Point p;
struct Node* next;
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化
struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化4.结构体内存对齐
我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：如何计算结构体的大小。
计算规则:结构体的对齐规则:
1. 第一个成员在与结构体变量偏移量为 0 的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的 较小值 。
VS 中默认的值为 8
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
这样看起来有点复杂,我们通过例子来进行分析.
#define _CRT_SECURE_NO_WARNINGS 1
#include
//结构体
struct s1 {
char c1;
int i;
char c2;
};
int main() {
printf("%d", sizeof(struct s1));
return 0;
} 
根据规则1. 第一个成员在与结构体变量偏移量为 0 的地址处。c1的数据类型为char,占一个字节
根据规则2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的 较小值 。
VS 中默认的值为 8
i的数据类型为int,所以对齐数为4,与vs的默认对齐数相比取最小值,即i存到4的整数倍的地址,i的数据类型为int,所占字节数为4.同理数据类型为char的c2对齐数为1与vs默认对齐数相比取最小值即一的整数倍的地址 如上图
根据规则3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。该结构体的成员变量的最大对齐数为4,即int i的对齐数,即结构体总的大小应为4的倍数现在只存了9个字节所以扩大到12个,即结构体的总大小为12.
struct S2
{
char c1;
char c2;
int i;
};
printf("%d\n", sizeof(struct S2));这个答案为8,大家可以按照规则自己练习一下.
struct S3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct S3));提示double所占字节为8,这个答案为16.
struct S4
{
char c1;
struct S3 s3;
double d;
};
printf("%d\n", sizeof(struct S4));这个涉及到结构体嵌套的问题,根据规则4来解决嵌套结构体的地址位置,这个大家认真思考一下,答案为32.
为什么存在内存对齐?
1. 平台原因 ( 移植原因 ) ：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2. 性能原因 ：
数据结构 ( 尤其是栈 ) 应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
问。
总体来说：
结构体的内存对齐是拿 空间 来换取 时间 的做法。
5.修改默认对齐数(vs)
#define _CRT_SECURE_NO_WARNINGS 1
#include
//修改默认对齐数
#pragma pack(2)
//结构体
struct S
{
char c1;
int i;
char c2;
};
int main() {
printf("%d\n", sizeof(struct S));
return 0;
} 默认对齐数修改为2,结构体大小为8.
#pragma pack()//取消设置的默认对齐数，还原为默认
结论：
结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。
6.结构体传参
struct S {
int data[1000];
int num;
};
struct S s = {{1,2,3,4}, 1000};
//结构体传参
void print1(struct S s) {
printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps) {
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址
return 0; } 上面的 print1 和 print2 函数哪个好些？
答案是：首选 print2 函数。
原因：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的
下降。
结论：
结构体传参的时候，要传结构体的地址。
6.结构体实现位段（位段的填充&可移植性）
1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以 4 个字节（ int ）或者 1 个字节（ char ）的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
//一个例子
struct S {
char a:3;//所占空间为3个比特位
char b:4;//所占空间为4个比特位
char c:5;//所占空间为5个比特位
char d:4;//所占空间为4个比特位
};
struct S s = {0};
s.a = 10; s.b = 12; s.c = 3; s.d = 4;
//空间是如何开辟的？位段的跨平台的问题
1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（ 16 位机器最大 16 ， 32 位机器最大 32 ，写成 27 ，在 16 位机
器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是
舍弃剩余的位还是利用，这是不确定的.
二、枚举
1.枚举类型的定义
enum Day//星期
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex//性别
{
MALE,
FEMALE,
SECRET
}；
enum Color//颜色
{
RED,
GREEN,
BLUE
};2.枚举的优点
枚举的优点：
1. 增加代码的可读性和可维护性
2. 和 #define 定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量
3.枚举的使用
增加代码的可读性.
#define _CRT_SECURE_NO_WARNINGS 1
#include
//计算器的实现
int Add(int x, int y) {
return x + y;
}
int Sub(int x, int y) {
return x - y;
}
int Mul(int x, int y) {
return x * y;
}
int Div(int x, int y) {
return x / y;
}
void mune() {
printf("***********************************\n");
printf("******* 1.加法 2.减法*********\n");
printf("******* 3.乘法 4.除法*********\n");
printf("************* 0.退出 *************\n");
printf("***********************************\n");
}
enum Option {
EXIT,
ADD,
SUB,
MUL,
DIV
};
int main() {
int input = 0;
int ret = 0;
int x = 0, y = 0;
do {
mune();
printf("请选择->");
scanf("%d", &input);
printf("请输入两个数->");
scanf("%d,%d", &x, &y);
switch (input) {
case ADD:
ret=Add(x, y);
printf("%d\n", ret);
break;
case SUB:
ret=Sub(x, y);
printf("%d\n", ret);
break;
case MUL:
ret=Mul(x, y);
printf("%d\n", ret);
break;
case DIV:
ret=Div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出\n");
break;
default:
printf("参数错误请重新输入!\n");
break;
}
} while (input);
return 0;
}
三.联合(共用体)
1.联合类型的定义
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));2.联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联
合至少得有能力保存最大的那个成员）。
union Un
{
int i;
char c;
};
union Un un;
printf("%d\n", &(un.i));
printf("%d\n", &(un.c));
un.i = 0x11223344;
un.c = 0x55;
printf("%x\n", un.i);3.联合大小的计算
联合的大小至少是最大成员的大小。
当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
union Un1
{
char c[5];
int i;
};
union Un2
{
short c[7];
int i;
};
//下面输出的结果是什么？
printf("%d\n", sizeof(union Un1));//8
printf("%d\n", sizeof(union Un2));//16总结
提示：这里对文章进行总结：
例如：以上就是今天要讲的内容，本文仅仅简单介绍了pandas的使用，而pandas提供了大量能使我们快速便捷地处理数据的函数和方法。