🎇作者：小树苗渴望变成参天大树
💖作者宣言：认真写好每一篇博客
🧨作者gitee:link

如 果 你 喜 欢 作 者 的 文 章 ，就 给 作 者 点 点 关 注 吧！

---

🎉前言

各位小伙伴们，大家好，博主今天又来更新好的文章了，在数据存储的那一章节，我们提到过，构造类型，这些类型都是由我们自己构造出来的，拥有我们想要的特性，那我们今天就具体来介绍一下这些构造类型（也叫自定义类型），话不多说，我们开始进入正文。

本章重点

一、结构体

结构体类型的声明
结构的自引用
结构体变量的定义和初始化
结构体内存对齐
结构体传参
结构体实现位段（位段的填充&可移植性）

二、枚举

枚举类型的定义
枚举的优点
枚举的使用

三、联合

联合类型的定义
联合的特点
联合大小的计算

---

💦一、结构体

1.1结构体类型的声明

struct tag
{
 member-list;
}variable-list;

例子：
struct Stu
{
	int age;
	char name[20];
}s1，s2;//全局变量s1,s2
int main()
{
	struct Stu s1 = {0};//局部变量s1，是不完全初始化
	return 0;
}

上面两种都是可以创建结构体类型的变量。

typedef用法：

第一种：
typedef struct Stu
{
	int age;
	char name[20];
}s1，s2,s3;//这个s1是结构体类型的重命名相当于struct Stu

第二种：
typedef struct Stu s1;//这样重命名也是可以的
typedef struct Stu s2;
typedef struct Stu s3;
int main()
{
	s1 s4 = {0};//局部变量s2
	s2 s5={0};//局部变量s5
	s3 s6={0};//局部变量s6
	return 0;
}

1.2特殊的声明

在声明结构的时候，可以不完全的声明。

//匿名结构体类型
struct
{
 int a;
 char b;
 float c;
}x;

这样创建变量：
struct s1???

不知道结构体类型的名字，所以我们在创建变量的时候只能在结构体后面去创建，不然这个结构体没法用，这样的好处是，你自己只需要使用一次，又不想要别人用的情况下，可以这样做。

来看下面的代码是否可行

struct
{
 int a;
 char b;
 float c;
}*p;
//在上面代码的基础上，下面的代码合法吗？
p = &x;

警告：
编译器会把上面的两个声明当成完全不同的两个类型。所以是非法的。我我们只是看着两个类型是一样的，实际上不一定一样。

1.3结构体的自引用

在结构中包含一个类型为该结构本身的成员是否可以呢？

//代码1
struct Node
{
 int data;
 struct Node next;//这个next变量里面还有一个data变量,一个next变量，
};
//可行否？
如果可以，那sizeof(struct Node)是多少？

这个类型会一直循环下去，所以不行，因为嵌套的是自己的类型，嵌套一个其他的结构体类型可以，例如：

struct Stu
{
	int age;
	char name[20];
};
struct per
{
	int sex;
	struct Stu info;
};

这样不会一直循环下去

正确的自引用方式：

//代码2
struct Node
{
 int data;
 struct Node* next;
};

//这是链表相关的知识，大家可以先了解一下

注意：

//代码一
typedef struct
{
 int data;
 Node* next;
}Node;

//解决方案：
typedef struct Node
{
 int data;
 struct Node* next;
}Node;

代码一是因为 左后的重命名是最后执行，到Node*next这条语句是，不认识Node，所以不行.

1.4结构体的初始化

struct Point
{
 int x;
 int y;
}p1={1,2};//在声明的时候创建了变量p1,直接初始化了

struct Point p2={1,2};

嵌套初始化：

struct Node
{
 int data;
 struct Point p;
 struct Node* next; 
}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化


struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

1.5结构体的内存对齐

我们已经掌握了结构体的基本使用了。

现在我们深入讨论一个问题：计算结构体的大小。

这也是一个特别热门的考点： 结构体内存对齐

首先得掌握结构体的对齐规则：

1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 从第二个成员变量开始要对齐到某个数字（对齐数）的整数倍的地址处。
   对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
   VS中默认的值为8
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

例子：

//练习1
struct S1
{
 char c1;
 int i;
 char c2;
};
printf("%d\n", sizeof(struct S1));

运行结果：

我们再来看一个例子：

//练习2
struct S2
{
 char c1;
 char c2;
 int i;
};
printf("%d\n", sizeof(struct S2));

在来一个例子：

//练习3
struct S3
{
 double d;
 char c;
 int i;
};
printf("%d\n", sizeof(struct S3));

我们在来看一个特殊的：

//练习4-结构体嵌套问题
struct S4
{
 char c1;
 struct S3 s3;
 double d;
};
printf("%d\n", sizeof(struct S4));

在来一个特殊的例子：

struct s
{
	int a;
	char c[5];//这相当里面呢有五个char类型的数据
	//char c1;
	//char c2;
	//char c3;
	//char c4;
	//char c5;
	//按照这样的格式来计算
	double d;
};

相信大家看来这么多的例子应该对结构的内存对齐和怎么计算大小应该弄的很清楚了。

那我们问什么存在内存对齐呢？？这样做会浪费一些空间啊，那为什么还存在呢？？
大部分的参考资料都是如是说的：

1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。

2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问

总体来说：

结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既要满足对齐，又要节省空间如何做：
让占用空间小的成员尽量集中在一起。-
例如：

//例如：
struct S1
{
 char c1;
 int i;
 char c2;
};//12
struct S2
{
 char c1;
 char c2;
 int i;
};//8

S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。

1.6修改默认对齐数

既然vs有默认对齐数，那这个对齐数不一定是合适的，所以我们可不可以修改默认对齐数呢？？答案是可以的，具体怎么来操作呢？？

#pragma pack(1)//设置默认对齐数为1
struct S2
{
 char c1;
 int i;
 char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

我们采用#pragma这个预处理指令可以实现这个操作我们再来看看修改结构体类型大小和默认对齐数大小结果对比：

我们可以使用修改后的对齐数来计算一下大小是否为6个字节。

结论：结构在对齐方式不合适的时候，我们可以自己更改默认对齐数。

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

在浅谈结构体那一节我们也具体介绍到结构体传参，我们说过结构体在传参的时候最好使用地址传参，这样比较好，但是那个时候知识觉得传递至可以修改里面的值，现在我从结构体类型大小来解释一下

函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。

如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

意思就是，我们在传一个参数过去，每个参数肯定有自己的空间大小，系统会把我们传过去较大的参数压栈成比较小的空间大小，参数越大，压栈时间和系统开销就越大，我们要每次都穿地址呢？？地址的一直为四个字节是比较小，我们经常使用的结构体类型大小都会超过4个字节，所以结构体在传参的时候最好都是传址。

1.8位段

结构体讲完就得讲讲结构体实现 位段 的能力。

1.8.1什么是位段

位段的声明和结构是类似的，有两个不同：

1.位段的成员必须是 int、unsigned int 或signed int 。
2.位段的成员名后边有一个冒号和一个数字。数字单元是bit

例子：

struct A
{
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
};
printf("%d\n", sizeof(struct A));

运行结果：
*
我们看到结果了，我们会想四个整型最少也为16个字节啊，这里怎么算出来的是8个字节呢？？

原因是我们在给每个成员类型进行分配空间的时候，这些字节的所以比特位不一定是都是用的，这样就会造成没有使用的比特位浪费的情况，我们把没有使用的比特位给下个要使用的变量使用，这样就会减少空间的浪费， 所以位段就是来解决这样的问题的

1.8.2位段的内存分配

我们具体来看实例：

//一个例子
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.8.3位段的跨平台问题

1. int 位段被当成有符号数还是无符号数是不确定的。
2. 位段中最大位的数目不能确定。（16位机器最大16，32位机器最大32，写成27，在16位机器会出问题。
3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

总结：跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。

💨二、枚举

枚举顾名思义就是一一列举。
把可能的取值一一列举。
比如我们现实生活中：

一周的星期一到星期日是有限的7天，可以一一列举。
性别有：男、女、保密，也可以一一列举。
月份有12个月，也可以一一列举

这里就可以使用枚举

2.1枚举类型的定义

enum Day//星期
{
 Mon,
 Tues,
 Wed,
 Thur,
 Fri,
 Sat,
 Sun
};
enum Sex//性别
{
 MALE,
 FEMALE,
 SECRET
}；
enum Color//颜色
{
 RED,
 GREEN,
 BLUE
};

里面的每一个都表示一个枚举常量，都是代表一个整型的值

这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值

例如：

enum Color//颜色
{
 RED=1,
 GREEN=2,
 BLUE=4
};

我们可以打印出来看看：

我们想要修改我们的枚举常量代表的值，必须在定义枚举类型的时候就需要进行初始化我们想要的值，不然其他任何地方都不能修改；

2.2枚举的优点

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

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

2.3枚举的使用

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

我们之前实现了一个计算器小程序，就可以使用枚举类型：

这样就很好的利用了枚举类型的特性。

🎄三、联合体

联合体也叫共用体

3.1联合类型的定义

联合也是一种特殊的自定义类型
这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间。
比如：

//联合类型的声明
union Un
{
 char c;
 int i;
};
//联合变量的定义
union Un un;
//计算连个变量的大小
printf("%d\n", sizeof(un));

运行结果：

我们可以看到联合体公用的确实是同一块空间。通过这个性质，我们可以知道联合体的特点了：

联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。

3.2联合大小的计算

我们来介绍一下联合的大小怎么计算

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

//代码一
union Un1
{
 char c[5];//五个字节，最大对齐数是1
 int i;//四个字节，最大对齐数是4
};
//代码二
union Un2
{
 short c[7];
 int i;
};

至少需要五个字节就可以存放下去，但是5不是4的整数倍，所以要扩大到8个字节，看运行结果：

大家可以自己去算算代码二的结果是多少

面试题：我们之前用指针来分析我们机器是大端存储还是小端存储，今天我们使用联合体来分析：

int main()
{
	union Un
{
	char c;
	int i;
};
un.i=1;
if(un.c==1)
{
	printf("小端\n");
}
else
{
	printf("大端\n");
}

}

相信大家看到这里对联合类型应该了解了吧，虽然用的频率没有结构体高，但我们也要会这些。以防万一要用到。

✨四、总结

今天我们就讲到这里，读者下去可以自己去理解理解，希望你们能好好的掌握。