前言：

那么好了好了，宝子们，从今天开始开始总结暑假博客，今天的主角：结构体，枚举，联合，来吧开始整活！⛳️

结构体

1.结构体类型的声明

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
例如：

struct Stu
{char name[20];char sex[5];int age;int id[20];
}x,y;

匿名结构体：

struct
{int a;char b;float c;
}x;

2.结构的自引用

//代码1
struct Node
{int data;struct Node next;
};
//可行否？
//如果可以，那sizeof(struct Node)是多少?//正确自应用：
struct Node
{int data;struct Node* next;
};

正确自引用：

//代码3
typedef struct
{int data;Node* next;
}Node;
//这样写代码，可行否？//no!no!no!nononono//解决方案：
typedef struct Node
{int data;struct Node* next;
}Node;
struct Point
{int x;int y;
}p1; //声明类型的同时定义变

3.结构体变量的定义和初始化

有了结构体类型，那如何定义变量，其实很简单。
有两种定义结构体变量的方式：

1. 在结构体末尾定义：

struct Point
{int x;int y;
}p1; //声明类型的同时定义变

3. 单独定义：

struct Point p1;

综合：

//初始化：定义变量的同时赋初值。
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 };//结构体嵌套初始化
//练习1
struct S1
{char c1;int i;char c2;
};

4.结构体内存对齐

结构体对齐的准则：
通俗易懂版：
官方版:

这也是一个特别热门的考点： 结构体内存对齐
管中窥豹（例一：）

//练习一：
struct S1
{char c1;//int i;char c2;
};

透析：

通过例题来理解结构体内存对齐规则：

//练习一：
struct S1
{char c1;//1 8 1int i;//4 8 4char c2;//1 8 1
};//练习二：
struct S2
{char c1;//1 8 1char c2;//1 8 1int i;//4 8 4
};//练习3
struct S3
{double d;//8 8 8char c;//1 8 1int i;//4 8 4
};
int main()
{printf("%d\n", sizeof(struct S1));//12printf("%d\n", sizeof(struct S2));//8printf("%d\n", sizeof(struct S3));//16return 0;
}

5.结构体传参

直接上代码：

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

6.结构体实现位段（位段的填充&可移植性）

结构体讲完就得讲讲结构体实现 位段 的能力。
位段的最小单位是：比特位（bit）

什么是位段
位段的声明和结构是类似的，有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。
例一：

struct A
{int _a : 2;//一次性开辟一个整型=4*8=32bitint _b : 5;int _c : 10;//a,b,c这三个公用第一次开辟的4个字节（int）=32bitint _d : 30;//从新开辟
};int main()
{printf("%d\n", sizeof(struct A));return 0;
}

也就是每次开辟空间的时候，都开辟一个数据类型的大小
（int=4个字节=48=32bit）
（char=1个字节=18=8bit）
位段计算规则：

//一个例子
struct S
{char a : 3;char b : 4;//a和b一个字节char c : 5;char d : 4;
};
int main()
{printf("%d\n", sizeof(struct S));return 0;
}
//空间是如何开辟的？

枚举

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开始，一次递增1，当然在定义的时候也可以赋初值

2.枚举的优点

我们可以使用 #define 定义常量，为什么非要使用枚举？ 枚举的优点：

1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量

3.枚举的使用

enum Color//颜色
{RED = 1,GREEN = 2,BLUE = 4
};
enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。
clr = 5;

联合

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));
printf("%d\n", sizeof(union Un2));

Un1:它里面最大成员的大小是1×5=5，但是还要满足联合体的大小是最大对齐数的整数倍，最大对齐数是4。也就是最终的结果是4的倍数，所以说不仅要大于5，而且要是4的倍数，所以说是8。
Un2:它里面最大成员的大小是2×7=14，但是还要满足联合体的大小是最大对齐数的整数倍，最大对齐数是4，也就是最终的结果是4的倍数，而且还要大于14，所以说是16。

---

好了，今天的分享就到这里了

如果对你有帮助，记得点赞👍+关注哦！
我的主页还有其他文章，欢迎学习指点。关注我，让我们一起学习，一起成长吧！
好了，今天的分享就到这里了