家人们欢迎来到小姜的世界，<<点此>>传送门 这里有详细的关于C/C++/Linux等的解析课程，家人们赶紧冲鸭！！！
客官，码字不易，来个三连支持一下吧！！！关注我不迷路！！！

---

前言

自定义类型是很重要的，学习好了自定义类型，之后的数据结构会比较好学一点，本章的重点是如何自己进行创造结构体、枚举和联合体以及这些知识的优点。

---

一、结构体

我已经在之前写过关于结构体的博客了，这里关于结构体的概念我们不过多赘述，我们简单概况一下：

【C初阶】初识结构体

（一）结构体的声明

1.结构的基础知识

2.结构的声明

我们以Stu为例直接概况一下结构体：

#include<stdio.h>

struct Stu 
{
	char name[10];
	int age;
}s1, s2;//全局变量，s1和s2是结构体变量

struct Stu s3, s4;//全局变量

typedef struct Stu1 //重命名Stu2
{
	char name[20];
	int age1;
	double score;
}Stu1;//Stu1是类型

int main() 
{
	struct Stu s5, s6;//局部变量
	Stu1 s7, s8;//局部变量
	return 0;
}

3.特殊的声明

在声明结构的时候，可以不完全的声明。下面的两个结构在声明的时候省略掉了结构体标签（tag）。如下：

//匿名结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], * p;

警告

那么问题来了，当我们main函数内部用p=&x可以吗？
答案肯定是不可以的，别看这上面struct结构体内部定义的都是一样的，但因为匿名结构体只能用一次，也就是说在编译器的角度，上面x和*p的声明是两个完全不同的两个类型，是非法的，不能指针去用。

4.结构的自引用

（1）引例

在开始之前，我们先引一个数据结构的链表的简单介绍:

我们发现链表是定义一个节点，这个节点可以存放这个数的数据，同样也可以找到下一个节点的位置，那我们先看下面一串代码，看看可不可以：

这串代码看似没什么问题，我去找下一个节点，可是发现，这个struct结构体的大小是无限大，为什么呢？因为struct Node next又可以分为int data和struct Node next，看似好像找了下个节点位置，可是为何struct这个结构体的大小是无限大呢？那我们就想了，既然要找到位置，那不如找地址，那我们进行重新定义一下：

这就很完美了，通过第一个节点去找到下一个节点的地址再去访问它即可。

（2）方式

第一种就和上面利用结构体指针进行定义，不再过多赘述了。
第二种就是利用重命名来进行定义，如下：

这个是很关键的，将那么一大串代码重命名成Node。而很多人学了匿名结构体类型就想了，那我用一用吧！接下来就写了如下代码，对不对呢？看后续的讲解：

此代码匿名的过火了，这是个结构体类型，怎么在内部直接进行省略struct，直接变成Node* next了呢？这是不是很奇怪，我们想，重命名是重新命名了那一整个结构体，而Node明显是在结构体内部的，我们应当是定义完再进行重命名，这结构体里面都没定义好，怎么就直接省略struct了呢？所以我们要老老实实写。

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

（1）定义

我们先来定义看一下：

（2）初始化

进行初始化很简单，加一个大括号即可，要进行打印的时候只需要按照不同的类型进行打印即可。那同样也有比较不常规的思路，要想输入是不规则的，那在前面加一个.即可。

struct Point
{
	int x;
	int y;
}p1 = {10, 20};

struct Point p2 = {2, 3};

struct S {
	int num;
	char ch;
	struct Point p;
	float f;
};

int main() {
	struct Point p3 = {1, 2};
	struct S s = { 10,'w',{2,3},1.2f };
	struct S s1 = {.num=10,.f=1.2f,.ch='e',.p.x=3,.p.y=6};
	printf("%d %c %d %d %f\n", s.num, s.ch, s.p.y, s.p.x, s.f);
	return 0;
}

6.结构体内存对齐

（1）偏移量

结构体内部的某个地址的偏移量是指结构体内存空间中某个字节的地址与结构体首元素地址的差值，是以字节为单位的，而存储结构是从低地址到高地址排列的。

（2）对齐数

是结构体的每个成员都有自己的对齐数，这个对齐数是编译器默认的对齐数与该成员字节的大小进行比较，取较小的那个字节大小。
ps:当我们在看成员的对齐数的时候，我们要注意的是在遇到数组这类情况的时候，我们要将数组成员看做多个内置类型成员来看待，例如int a[5]的字节大小就是4*5=20，而对齐数的大小依旧是类型的大小与默认对齐数大小中的较小值。
ps:VS环境下默认对齐数为8；LInux gcc环境下没有默认对齐数，这个成员是多少个字节就是多少对齐数。

（3）概念

我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。
这也是一个特别热门的考点： 结构体内存对齐
先来一串代码热热身，大家可以想一想这串代码输出的是什么：

#include<stdio.h>
struct S1 {
	char c1;
	int i;
	char c2;
};
struct S2 {
	char c1;
	char c2;
	int i;
};
int main() {
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}

相信你肯定拷贝到编译器里面，结果是12和8，这怎么那么奇特，按理来讲不应该是char占1个字节，int 占4个字节，那不就是一个struct占6个字节吗？？这怎么输出的还不一样，两个都不一样，咋办？接下来我会给大家引进一个新的知识点：结构体的内存对齐，所以首先得掌握以下的概念：

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

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

慢慢来，我们来进行讲解一下，以上面的代码为例：

我们是先用第一个元素的字节放在偏移量为0处，往下放占的字节数量，根据上面那道解析char占1个字节，所以放1个即可，而从第二个成员开始，就需要跟默认对齐数进行比较取最小那个，上题取的是4，所以往下找4的整数倍，发现第4个偏移量之前已经是4个字节了，那就从4开始往后放一个整型数，即4个字节，再往后就是char类型，与8比较取最小为1，则往后一个偏移量，那这就完了吗？还有第三步，我们数一数总共偏移量多少，发现是9，所以我们就需要算结构体总大小为所有成员的对齐数中最大对齐数的整数倍，也就是4的整数倍，那就是12了，那我们移动到12顶上的位置，那那么多浪费的空间怎么办？那就只能浪费了。

（4）小知识offsetof

算的是从哪里开始的偏移量：

代码如下：

#include<stdio.h>
#include<stddef.h>
struct S1 {
	char c1;
	int i;
	char c2;
};
struct S2 {
	char c1;
	char c2;
	int i;
};
int main() {
	//printf("%d\n", sizeof(struct S1));
	//printf("%d\n", sizeof(struct S2));
	printf("%d\n", offsetof(struct S1, c1));
	printf("%d\n", offsetof(struct S1, i));
	printf("%d\n", offsetof(struct S1, c2));
	return 0;
}

（5）练习

（6）嵌套结构体

大家是不是想到了怎么前面概念讲了嵌套结构体成员，怎么练习中没有讲到的，接下来我们将讲述嵌套结构体：

前面都一样，但是到了嵌套那边就略微有些差别，我们要找对齐数还是原本那套思路与默认对齐数比较吗？答案肯定是不是的，我们要找的对齐数是从上面被嵌套的结构体成员中找最大的成员，然后以它的整数倍进行找对齐数，就比如下一个偏移量是1，那肯定不是8的倍数，那就往后找，找到8以后发现是8的倍数，所以从8开始往后偏移16个字节即可，之后的步骤就一样了，直到算到总的字节大小的时候，就需要另一个概念了，就是不管怎么样，算的就是所有对齐数中的最大对齐数的倍数。

（7）为什么存在内存对齐?

为什么存在内存对齐?
大部分的参考资料都是如是说的：

1. 平台原因(移植原因)：
   不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
   定类型的数据，否则抛出硬件异常。
2. 性能原因：
   数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
   原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
   问。
   总体来说：
   结构体的内存对齐是拿空间来换取时间的做法。
   解释：
   

（8）建议

建议小的成员数挨在一起，这样节省空间，下面方法为优：

7.修改默认对齐数

在之前的讲解中有一个默认对齐数的概念，我们讲在VS环境下，默认对齐数是8，而在Linux gcc环境下是没有对齐数的，而我们能不能修改修改对齐数呢？答案是当然可以。那我们就需要一个头：#pragma pack() - 可以设置默认对齐数。


但我们修改了以后发现空间上是省略了，但是似乎时间上省略不了，要去访问得一个字节一个字节访问，要是几万个这种放在一起，这对计算机要求太高了，所以用途就是大家根据实际需求进行更改，所以结构在对齐方式不合适的时候，我们可以自己更改默认对齐数。

8.结构体传参

这个似乎是我们的老朋友了，在【C初阶】结构体中已经进行讲解过了，但大家可能有点生疏也不想跳转到那条博客去从头往后看了，那我就简简单单讲一下吧！

#include<stdio.h>
struct S
{
	int data[1000];
	int num;
};

//结构体传参
void print1(struct S s)
{
	printf("%d\n", s.num);
}
//结构体地址传参
void print2(struct S* ps)
{
	printf("%d\n", ps->num);
}

int main()
{
	struct S s = { {1,2,3,4}, 1000 };
	print1(s);  //传结构体
	print2(&s); //传地址
	return 0;
}

那我们也说了，传地址的方式是最好了，因为我只用去访问它的地址就好了，不用另外创建一块空间，要是创建另外一块空间那需要时间和空间上的消耗，所以得出以下结论：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
所以首选传参是地址。

（二）位段

在讲述完前面的结构体的知识，位段的知识是十分重要的，因为它节省了cpu很多的空间，是计算机的好帮手！

1.什么是位段

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

举个例子：
大家看看下面的代码觉得应该打印出来什么？

#include<stdio.h>
struct A
{
	int _a : 2;
	int _b : 5;
	int _c : 10;
	int _d : 30;
};
int main() {
	printf("%d\n", sizeof(struct A));
	return 0;
}

这计算的是结构体的大小，我们进入结构体发现用以前的老办法算出来是16，那结果真的是16吗，相信你肯定在vs中运行试了一下，这咋还缩半了，变成8了，那这就得好好讲解了：

位段中的位，指的是二进制位，也就是说冒号后面的数是指的是占的二进制位。

既然这么神奇，那计算机是如何将16个字节缩减到8个字节的空间的呢？那就接着讲：

2.位段的内存分配

概念：

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型
2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。
3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

有了上面的概念，我们就可以依据概念来分析一下这串代码的内存分布：

那同样是要有需要注意的事项：
1.我们在定义冒号后面的位数不能大于当前机子的比特位数。
2.当剩余空间不足时，是需要重新开辟一块空间来存放的。

那所以位段到底是怎么用的呢？举个例子：

#include<stdio.h>
struct S
{
	char a : 3;
	char b : 4;
	char c : 5;
	char d : 4;
};

int main() {
	struct S s = { 0 };
	s.a = 10;
	s.b = 12;
	s.c = 3;
	s.d = 4;

	return 0;
}

当我已经规定了结构体S的大小了的时候，而下面给的赋值赋的是10进制，位段的位是2进制，那我们就是会发生截断，只取从右往左的所对应的二进制位，然后从低字节往高字节放位段，放完一个再放下一个，如果少了空间，那就需要再开辟一块空间即可。

3.位段的跨平台问题

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

4.位段的应用

这个应用目前我的水平肯定是不够的，那就划一下水吧，大家可以看看下面的图片，就相当于在整个大网络的环境下，我们在不同的地方分配不同的空间，一些不必要浪费的空间给好好利用一下，那网速岂不是就会变快了！

5.总结

1.跟结构相比，位段可以达到同样的效果，但是可以很好的节省空间，但是有跨平台的问题存在。
2.位段只能放在结构体中。

二、枚举

（一）简单介绍

枚举顾名思义就是一一列举，把可能的取值一一列举。
就好比我们日常生活中：
一礼拜是星期一到星期七，是可以一一列举的；
性别有男、女和保密，也是可以一一列举的；
月份有12个月，是可以一一列举的。
格式如下：

（二）枚举类型的定义

#include<stdio.h>
enum Day//星期
{
	Mon,
	Tues,
	Wed,
	Thur,
	Fri,
	Sat,
	Sun
};
enum Sex//性别
{
	MALE,
	FEMALE,
	SECRET
};
int main() {
	enum Day d;
	enum Sex s;

	return 0;
}

以上定义的 enum Day ， enum Sex ， enum Color 都是枚举类型。{ }中的内容是枚举类型的可能取值，也叫枚举常量。
这些可能取值都是有值的，默认从0开始，一次递增1，当然在定义的时候也可以赋初值，这是对枚举常量进行赋初值，不是进行改变值的操作。

那我们先不赋值打印看一下默认值：

那我们进行定义处进行赋初值吧！

那假如说是给一个赋初值，其他的都不赋初值呢？答案很简单，赋初值的那个打印的就是初值，而不赋初值的按照赋值的+1，第一个枚举常量不赋值默认为0。如下情况：

（三）枚举的优点

枚举的优点：

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

接下来一一分析：
第一点：当我们进行实现用数字进行不同功能的时候，我们用枚举类型进行数字和枚举常量的匹配。在switch中是十分方便的，当我们输入1,2,3,4,5,6……时候可以直接用枚举常量来解决，是不是更加方便了。
第二点：枚举是有自己的类型的，是枚举类型的，而#define是没有类型检查的，没有规则束缚着#define所以就会不严谨乱了套，而enum是有类型的，是有束缚的。
第三点：把同一个类型的枚举常量放在一起，将这些进行封装在一起，是很方便的。
第四点：调试很方便的，创建变量后是可以进行调试的。
第五点：可以进行封装，装多个常量。

（四）枚举的使用

大家看看图片，我们要进行类型的匹配，所以就需要等号两边是一样的类型，左边的类型是枚举类型（enum Sex），右边如果是2，是一个整型类型，与左边的类型不匹配，是个bug。

我们看一下枚举的大小：

三、联合（共用体）

（一）联合类型的定义

1.联合也是一种特殊的自定义类型这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
2.关键字是：union

#include<stdio.h>
//联合类型的声明
union Un
{
	char c;
	int i;
};
int main() {
	//联合变量的定义
	union Un un;
	//计算连个变量的大小
	printf("%d\n", sizeof(un));
	return 0;
}

（二）联合的特点

1.概念

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

2.解析

当我们进行打印上面那个代码的时候，发现是4，怎么就四个字节的空间呢？这是不是很奇怪，按道理来讲应该五个字节，要是struct的话那不应该是8个字节吗？那就需要代码＋运行来帮助我们进行理解了：

我们发现这三个的地址是一样的，那就是从一样的地址出发用自己的字节数，i和c共用这一块空间，但这两个不能共同使用，只能一个一个使用，所以联合体内部是至少保存最大的字节数。

当我们想了，这个联合体实在是太节省空间了，那这个联合体真的是有多大空间就装多少东西吗？那我们往后看吧！

（三）联合大小的计算

1.简单介绍

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

2.解析

我们大家看一看下面的这串代码，按照常规思路想这个代码输出的应该是5，因为如果单纯看前面的定义大家可能觉得是5，但看完计算的规则以后就知道了应该是最大对齐数的整数倍，也就是8。

3.练习

大家算一算以下代码输出的值：

#include<stdio.h>
union Un {
	short c[7];
	int i;
};
int main() {
	printf("%d\n", sizeof(union Un));
	return 0;
}

答案是16，是要到最大对齐数的整数倍哦！

（四）面试题

判断当前计算机的大小端存储

其实有两种做法，一种做法我们在之前讲数据存储的时候已经讲述过了，我们再来讲述一遍吧！

#include<stdio.h>
int main() {
	int a = 1;//0x00 00 00 01
	//低----------------------高
	//01 00 00 00  -- 小端
	//00 00 00 01  -- 大端
	//取出四个字节的起始地址并只取一个字节
	if (*(char*)&a == 1) {
		printf("小端\n");
	}
	else {
		printf("大端\n");
	}

	return 0;
}

那当然还有方法，那就是利用联合体：
将大的字节un.i赋值为1，我们看小的字节un.c取的第一个字节大小。

---

总结

到这里，自定义类型——结构体、枚举和联合体讲述的很详细了，大家如果仔细看了上面的知识，那肯定对自定义类型有了很深刻的理解，在未来的编程环境中慢慢加入这些元素，相信大家肯定就会完全掌握这些知识的！！！

---

客官，码字不易，来个三连支持一下吧！！！关注我不迷路！！！