●🧑个人主页:你帅你先说.
●📃欢迎点赞👍关注💡收藏💖
●📖既选择了远方，便只顾风雨兼程。
●🤟欢迎大家有问题随时私信我！
●🧐版权：本文由[你帅你先说.]原创，CSDN首发，侵权必究。
目录
- 1.结构体
- 1.1结构体的声明
- 1.2结构体的特殊声明
- 1.3结构的自引用
- 1.4结构体变量的定义和初始化
- 1.5结构体内存对齐
- 1.6修改默认对齐数
- 1.7结构体传参
- 2.位段
- 2.1什么是位段
- 2.2位段的内存分配
- 2.3 位段的跨平台问题
- 3.枚举
- 3.1枚举类型的定义
- 3.2枚举的优点
- 3.3枚举的使用
- 4.联合体
- 4.1联合体类型的定义
- 4.2联合体大小的计算
1.结构体
1.1结构体的声明
struct stu
{
//成员列表
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号;
}b1,b2;//变量列表 用所创建的结构体定义的两个全局变量
struct 是结构体关键字
stu 是结构体的标签名
1.2结构体的特殊声明
//匿名结构体类型
struct
{
int a;
char b;
float c;
}s1,s2;
此时结构体没有标签名，只能在变量列表创建变量。
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20], *p;
在上面代码的基础上，下面的代码合法吗？
p = &x;
💡:编译器会把上面的两个声明当成完全不同的两个类型，所以是非法的。
1.3结构的自引用
struct Node
{
int data;//数据域
struct Node* next;//指针域
};
1.4结构体变量的定义和初始化
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};//结构体嵌套初始化
1.5结构体内存对齐
什么是结构体内存对齐？
我们用一个练习来引出。
struct
{
char c1;
int i;
char c2;
};
int main()
{
printf("%d\n", sizeof(struct S1));
}
这段代码的结果很多人肯定会以为是6个字节。
实际上是12个字节，为什么呢？就是因为内存对齐。
结构体内存对齐规则
1.结构体的第一个成员永远放在结构体起始位置偏移量为0的位置。
2.结构体成员从第二个成员开始，总是放在偏移量为一个对齐数的整数倍处。
对齐数=编译器默认的对齐数和变量自身大小的较小值
vs下-默认对齐数是8
Linux-没有默认对齐数
3.结构体的总大小必须是各个成员的对齐数中最大那个对齐数的整数倍
4.如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整
体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
我们以上面这道题为例
第一个成员是char类型的所以占一个字节(对应图中红色块区域)，假设是在vs环境下运行，因为第二个成员是int类型的，字节数为4，而vs的对齐数为8，取最小值为4，所以只能找4的倍数，所以从4开始占用4个字节的空间(对应图中蓝色区域)，第三个成员是char类型，字节数为1，vs对齐数为8，取最小值为1，所以只能找1的倍数，所以从8开始占用1个字节的空间。到这里还没结束，别忘了规则中的第三条，各个成员中对齐数的最大值是4，4和8已经被占了，所以只能是12，所以这个结构体最终是12个字节。
结构体嵌套问题
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
这类问题只要遵循第四条规则就可以做出来了，其它步骤与上面那题相同。
为什么存在内存对齐？
1.平台原因(移植原因)
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2.性能原因
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
总结：
结构体的内存对齐方式实际上是一种拿空间换时间的方法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，所以我们建议让占用空间小的成员尽量集中在一起。
1.6修改默认对齐数
#pragma pack(8)//将默认对齐数设为8
1.7结构体传参
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;
}
在传参的时候我们首选print2的方式，因为函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
2.位段
2.1什么是位段
位段的声明和结构是类似的，但有两个不同：
1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};
如果我们去计算这个结构体会发现它的大小是8。
为什么呢？
首先，位段的这个为指的是二进制位(bit位)。
struct A
{
int _a:2;//2个bit位
int _b:5;//5个bit位
int _c:10;//10个bit位
int _d:30;//30个bit位
};
为什么要有位段呢？我们发现，在生活中有些数据的存储用不到太大的空间，比如年龄，无非是0-100，而4个字节也就是32个bit位能存储的数据比这大的多，所以就有了位段的定义，用来节省空间。
2.2位段的内存分配
- 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型。
- 位段的空间上是按照需要以**4个字节（ int ）或者1个字节（ char ）**的方式来开辟的。
- 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。
C语言中位段是如何开辟空间的呢？
举个🌰:
struct S
{
char a:3;
char b:4;
char c:5;
char d:4;
};
struct S s = {0};
s.a = 10; s.b = 12; s.c = 3; s.d = 4;
当你要接下来往下存时，会发现空间不够了，所以系统会再开辟一个字节的空间，但剩下的这一个字节要怎么办呢？前面我们讲过结构体的内存对齐，采用空间换时间，这里我们也假设这1个字节浪费掉。
接下来接着存储空间又不够了，所以会再开辟一个1字节的空间，剩下三个空间我们假设先浪费掉。
那我们要怎么验证它是对的呢？我们可以在编译器上通过内存监视去观察。
结果跟我们假设的一样，这个时候你对位段在内存中是怎么存储的就很清楚了。
2.3 位段的跨平台问题
- int 位段被当成有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机 器会出问题。
- 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
- 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是 舍弃剩余的位还是利用，这是不确定的
总结:跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
3.枚举
枚举顾名思义就是一一列举。
把可能的取值一一列举。
比如我们现实生活中：
一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举
3.1枚举类型的定义
enum Day//星期
{
Mon,
Tues,
Wed,
Thur,
Fri,
Sat,
Sun
};
enum Sex//性别
{
MALE,
FEMALE,
SECRET
}；
enum Color//颜色
{
RED,
GREEN,
BLUE
};
{}里的类型叫枚举常量，这些枚举常量都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值。
3.2枚举的优点
我们可以使用 #define 定义常量，为什么非要使用枚举？
枚举的优点：
1. 增加代码的可读性和可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨。
3. 防止了命名污染（封装）
4. 便于调试
5. 使用方便，一次可以定义多个常量
3.3枚举的使用
前面的文章分享过三子棋的制作，当时我们有做一个菜单，0表示exit，1表示play，学了枚举，我们可以给这些数字附上意义，能更直观的理解程序，例如我们举一个写计算器的例子。
enum Option
{
EXIT,//0
ADD,//1
SUB,//2
MUL,//3
DIV//4
};
void menu()
{
printf("******************************\n");
printf("**** 1. add 2. sub ****\n");
printf("**** 3. mul 4. div ****\n");
printf("**** 0. exit ****\n");
printf("******************************\n");
}
int main()
{
int input = 0;
do
{
menu();
printf("请选择:>");
scanf("%d", &input);
switch (input)
{
case ADD:
//加法
break;
case SUB:
//减法
break;
case MUL:
//乘法
break;
case DIV:
//除法
break;
case EXIT:
//退出
break;
}
} while (input);
return 0;
}
4.联合体
4.1联合体类型的定义
联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
举个🌰:
//联合类型的声明
union Un
{
char c;
int i;
};
//联合变量的定义
union Un un;
//计算联合体变量的大小
printf("%d\n", sizeof(un));
联合体大小的计算结果是4。
实际上你去输出un、i、c的地址你会发现它们的地址是相同的，这就能解释为什么是4个字节了。这个时候你就明白了联合体的大小至少是最大成员的大小，为什么说至少，待会联合体大小的计算中会告诉你答案。联合体又名叫共用体，共用了同一块空间。
我们之前讲过一个判断大小端的问题，是取出1个字节的内容，学了联合体后，我们可以用联合体的方法来判断大小端。
union U
{
char c;
int i;
}u;
int main()
{
u.i = 1;
if (u.c == 1)
{
printf("小端\n");
}
else
{
printf("大端\n");
}
return 0;
}
如果没看懂的话来看看下面这张图
u.c相当于就是取出它第一个字节的内容，和之前用指针的方法类似。
4.2联合体大小的计算
联合的大小至少是最大成员的大小。 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
举个🌰:
union Un1
{
char c[5];//5
int i;//4
};
union Un2
{
short c[7];//14
int i;//4
};
int main()
{
printf("%d\n", sizeof(union Un1));//8
printf("%d\n", sizeof(union Un2));//16
return 0;
}
这里以vs为例（默认对齐数为8）
首先Un1中c[5]的字节数是1,vs对齐数为8，所以c的对齐数是1，i的字节数是4，vs对齐数为8，所以i的对齐数为4，所以最大对齐数为4，最终大小只能是4的倍数，而5不是4的倍数只能找8，所以Un1的大小为8，同理Un2(可以自己动手算一下)的大小为16。
到这里有关自定义类型的知识点就全部讲完了。
在这举国同庆的日子里，我还在为大家奋斗
求求大家离开前记得一键三连(长按👍即可)
