今日主题是自定义类型的知识点的整理，大家帮忙斧正下！

目录

一，结构体

1，结构体的声明

2，结构体自引用

3，结构体内存对齐(非常重要)

4，修改默认对齐数

5，结构体传参

二，位段

1，位段定义

2，位段的内存分配

3，位段的跨平台性

三，枚举 

​​​​​​​3.1，枚举类型的定义

3.2，枚举的优点

四，联合（共用体）

4.1，联合的定义

4.2，联合的特点

4.3，联合的大小

一，结构体

1，结构体的声明

基础声明：

不完全声明：

不完全声明，就是省略掉结构体标签（名字），也成为匿名结构体

但是这有一点谨记，即使两个匿名结构体的成员列表都相同，但是他们任然是属于不同的类型。

例如：p = &x;

 这个就是不合法的，因为变量p与&x的类型不兼容，他们是不同类型的结构体变量。

2，结构体自引用

结构体自引用：在结构中包含一个类型为该结构本身的成员，有点递归的那么点意思。

//代码1
struct Node
{
 int data;
 struct Node next;
};
//可行否？

那按照意思就是这样写出的代码，那可行吗?答案是不行的，因为就相当于在一个结构体内部又套了一个自身的结构体，就这样一直套了下去，那你想想这个结构体最终得有多大，所以这种方法肯定是不可行的。

这里我们就类比一个知识，就是数据结构里面的链表，一个数据的存储空间里面包含了数据域与指针域，指针域中放的是下一个有关联的数据的地址，这样就可以把数据像链子一样串了起来，那这里可以用同样的方法，把结构体里面放一个指向自身的结构体指针就行了。

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

引申一下，typedef 用来类型重命名，那下面这种代码可行吗？

typedef struct
{
 int data;
 Node* next;
}Node;
//这样写代码，可行否？

首先，你可以用typedef对一个匿名结构体重命名，但是在这里它是结构体的自引用，就相当于你要去重命名为Node,但是你结构体内部就已经先用了，这就相当于先有鸡还是先有蛋的问题了，所以是不行的。也即是在自引用的条件下，你就算是重命名了，也不能先在结构体里面用。

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

3，结构体内存对齐(非常重要)

结构体内存对齐，其实本质上我们要解决的是计算结构体大小。

struct S1
{
 char c1;
 int i;
 char c2;
};
int main(){
printf("%dn", sizeof(struct S1));
return 0;
}

首先，看这段代码，大家可能会认为这个结构体大小不就是6嘛，两个char型加一个int型，但事实上结果是8，这里就是因为结构体内存对齐导致的，那如何去进行对齐呢？

对齐规则：

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

详解：

提到了默认对齐数，点一个点在vs编译器下,默认对齐数是8，在linux环境下是没有默认对齐数的概念的，这时候其自身的大小就是默认对齐数。 

那么说是这么说，那真的在内存中就是这么对齐存储的吗？

这里给大家介绍一个宏，可以用来计算结构体成员地址相对于起始地址的偏移量。我们来验证一下！

 例如还是上面的S1，程序如下：

可以看到，偏移量与我们上面分析的是一样的，所以结构体中的对齐规则是没有问题的。

 

结构体嵌套问题：

struct S1
{
	char c1;
	int i;
	char c2;
};
struct S4
{
	char c1;
	struct S1 s1;
	double d;
};
int main() {
	printf("%dn", sizeof(struct S4));
	return 0;
}

解析：

总结一下，单纯只是计算结构体的大小时，我们只需要先找到整个结构体的最大对齐数，然后整个结构体的大小肯定是个最大对齐数的倍数，然后你看是几倍，能够把几个成员放下，那么这个时候，这个倍数的数就满足既能放下成员，而且最大对齐数的倍数。

那为什么存在内存对齐?

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

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

总体而言，结构体的内存对齐是拿空间来换取时间的做法。那么既然我们结构体内部有内存对齐的操作，所以我们在设计结构体的时候也就应该注意，让占用空间小的数据尽量集中在一起，因为这个时候浪费的那些空间刚好可能就能放下这些数据，就能够达到节省一点空间的目的。

4，修改默认对齐数

VS环境下默认对齐数是8，这个默认对齐数是可以改的。

#include
#pragma pack(4)
struct S1
{
	char c1;
	double c2;
};
#pragma pack()
int main() {
	printf("%dn", sizeof(struct S1));
	return 0;
}

上面的这段代码的结构是12，原本的结果应该是16，但是当我们把默认对齐数改成4后，结果就变成了12。

注意：虽然说默认对齐数可以改，但是也不是随便让你改着玩的，一般就是8，你就算改，改的值也应该是2的倍数才比较好。

所以，不要随意修改默认对齐数，编译器让我们能改，但不是随便改。

5，结构体传参

两种传参方式：

第一种：实参用结构体，形参也用一个结构体变量接收，这个时候形参就是实参的一份临时拷贝。那如果结构体很大，就比较浪费空间。

第二种：实参用结构体的地址，形参用结构体指针来接收。

两种方法，最好是采用第二种，因为函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

二，位段

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

1，位段定义

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

1.位段的成员必须是 int、unsigned int 或signed int 。

2.位段的成员名后边有一个冒号和一个数字。

例如：

struct A
{
 int _a:2;
 int _b:5;
 int _c:10;
 int _d:30;
};

A就是一个位段类型。

比较一下结构体与位段的大小有什么区别？

可以看到，位段类型的变量A的大小明显要小很多，这是因为后面跟的数字就限制了大小只可能最大为这么多。位段类型的存在一定是在特定的业务条件下的，比如_a只分配了两个字节，那二进制就只可能是00，01，10，11，代表0，1，2，3四个十进制数，那如果这个业务里面_a就只需要这四个值，我们就只需要给其分配两个字节就好了，这样就能节省空间。

2，位段的内存分配

1. 位段的成员可以是 int unsigned int signed int 或者是 char （属于整形家族）类型

2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的方式来开辟的。

3. 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使用位段。

详细解析：

看下面这个例子：

 这里是我们的自己分析假设过程，那具体到底是不是这样呢？我们来看看编译器的内存图：

求取结构体S的大小：

 

从结果可以看出，结构体S确实是占三个字节，并且在内存中的存储方式也和我们分析的一样。 

3，位段的跨平台性

1. int 位段被当成有符号数还是无符号数是不确定的。

2. 位段中最大位的数目不能确定。（比如对于int类型的数据，16位机器是两个字节也就是最大16位，32位机器最大32位，所以你在设定数据所占位时就不能超过机器的最大限制)

3. 位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。

4. 当一个结构包含两个位段，第二个位段成员比较大，无法容纳于第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。

三，枚举 

枚举：顾名思义就是一一列举，把可能的取值一一列举。

​​​​​​​3.1，枚举类型的定义

enum Sex//性别
{
 MALE,
 FEMALE,
 SECRET
}；

这里的Sex就是枚举类型，因为性别的值可以一一列举出来，要么男，要么女，要么保密。

而枚举类型里面的可能取值就叫做枚举常量，它是有值的，从第一个开始，由0往后递增。当然这只是默认情况，你也可以自己赋初值，这个时候没有赋初值的就在前一个的基础上加1就是其默认初值。

例如：

 这里大家要注意，既然里面的值是枚举常量，那么常量的值就是不能改的，我们上面在枚举类型里面赋值那是初始化值，但是你如果在外面想对枚举常量初始化好的值进行修改是不行的。

3.2，枚举的优点

枚举的优点：

1. 增加代码的可读性和可维护性

2. 和#define定义的标识符比较枚举有类型检查，更加严谨。

3. 防止了命名污染（封装）

4. 便于调试 (对于define而言，它在预编译就给你把符号进行了相关的替换，所以你最终调试的时候就是替换后的代码，和源码是不一样的，这个时候就不是很便于调试。但是枚举类型的数据虽然有值，但不会进行替换，便于调试)

5. 使用方便，一次可以定义多个常量

enum Color c = 1;
//这里其实就是想把c赋值为RED,c语言对类型检查不是很严格，但是在c++下这句代码是错误的，因为你将int类型的数据赋值给枚举类型的数据，类型不兼容，enum是有类型检查的

注意：在定义变量名字的时候不要和枚举常量的名字冲突，因为枚举类型的数据是不支持限制所属范围的。

四，联合（共用体）

4.1，联合的定义

联合也是一种特殊的自定义类型，这种类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。同时时间只能用一个。

可以看到，联合的大小是4而不是两个成员大小相加的5，并且联合的地址与其两个成员的地址也是一模一样的，所以是共用了空间的，这也是为什么还会叫做共用体了。

注意：既然是共用了，所以你改动其中一个的值另外的一个也会变，所以成员在使用的时候就是只能用一个，你用i就不能用c，这也就是联合的应用场景。

4.2，联合的特点

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

根据联合的特点，我们是可以用来判断机器是小端存储还是大段存储的。

原方法：
int main() {
	int x = 1;
	if (1 == *(char*)&x) {//把x强壮为char*后拿到第一个字节的内容，看是不是00000001，也就是1
		printf("小端");
	}
	else {
		printf("大端");
	}
}

联合：
int check_sys() {
	union Un
	{
		char c;
		int i;
	}u;
	u.i = 1;
	return u.c;
}
int main() {
	int ret = check_sys();
	if (1 == ret ) {
		printf("小端");
	}
	else {
		printf("大端");
	}
}

运用联合的思想就是一个整形的成员和一个字符型的成员，你把整型的成员赋值为1，那么这个时候字符型的成员因为是共用空间的，所以也会被赋值，那如果是小端，第一个字节就是00000001，这块空间又是共用的，所以字符型成员的值应该是1。

4.3，联合的大小

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

注意：联合也是有对齐的，规则与结构体对齐一样。

union Un
{
	short arr[7];//对于数组，我们看对齐数是参照的其数值的类型而不是数组的元素个数。2，8  所以对齐数是2
	int i;//对齐数是4
}u;
int main() {
	printf("%un", sizeof(u));
}

这里的结果是16，因为arr数组的大小是14，至少是最大成员的大小，所以肯定14往上走，而又要求是最大对齐数的倍数，所以只能是16，这里前四个字节就是共用的。

今天的博文就到这，如果大家觉得写的还不错的哈，还请帮忙点点赞哦，十分感谢你们，我们下次再键豁嘻嘻！