自定义类型详解（保姆级教程）
在本篇博客中，将会对三种自定义类型结构体，枚举，联合体进行详细介绍，干货满满，建议收藏！
目录
一、结构体
1.1 结构体的声明
1.1.1 结构的基础知识
1.1.2 结构的声明
1.1.3 特殊的声明
1.2 结构体的自引用
1.3 结构体类型重命名
1.4 结构体变量的定义和初始化
1.4.1 结构体变量的定义
1.4.2 结构体变量的初始化
1.5 结构体成员变量的访问
1.6 结构体内存对齐
1.6.1 结构体的对齐规则
1.6.2 例题
1.6.3 为什么存在内存对齐？
1.6.4 建议
1.6.5 修改默认对齐数
1.7 结构体传参
1.7.1 结构体传参
1.7.2 结构体地址传参
1.7.3 总结
二、位段
2.1 什么是位段？
2.2 位段的内存分配
2.3 位段的跨平台问题
三、枚举
3.1 枚举类型的定义
3.2 枚举的优点
四、联合（共用体）
4.1 联合体类型的定义
4.2 联合的特点
4.3 联合大小的计算
一、结构体
当我们需要描述一些事物即复杂对象，使用简单的int、short等类型无法将其完整的描述出来的时候，我们就需要有结构体类型，比如我们想要描述一个人，人有姓名、年龄、身高、性别等特性，我们在描述人这一复杂对象的时候就可以创建一个结构体类型。
1.1 结构体的声明
1.1.1 结构的基础知识
结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是不同类型的变量。
1.1.2 结构的声明
我们首先要知道结构体关键字，struct，对于结构体类型的定义是按照以下形式来定义的。
例如我们想要描述一个学生，我们就可以创建一个标签名为Stu的结构体类型来描述学生这一复杂对象：
学生有名字、年龄、性别和学号等特性，在我们创建的结构体类型中就应该有这些特性。
struct Stu
{
char name[20]; //名字
int age; //年龄
char sex[5]; //性别
char id[20]; //学号
};
或者我们想要描述一本书，书是一个复杂对象，我们可以创建一个标签名为Book的结构体类型：
书有书名、作者、价格和编号等特性。
struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
};
1.1.3 特殊的声明
在对结构体声明的时候，我们也可以不写标签名，这种结构体类型就叫做匿名结构体类型，，注意匿名结构体类型只能使用一次，即创建一次变量。
下面就是一个匿名结构体类型：
struct
{
int a;
char b;
float c;
}x;
//匿名结构体类型只能在这里创建变量，在下面的主函数中无法创建变量，即只能使用一次
在匿名结构体这里我们需要注意：定义了两个匿名结构体类型，这两个匿名结构体类型中的成员变量相同，编译器并不会认为他们相同，会把他们理解为两种完全不同的类型。
我们来验证以下上面的结论，有两个成员变量相同的结构体：
struct
{
char book_name[20];
char author[20];
int price;
char id[15];
}s1;
struct
{
char book_name[20];
char author[20];
int price;
char id[15];
}*p; //p是匿名结构体类型的指针变量我们使用这两个成员变量相同的结构体分别创建了结构体变量s1和结构体指针p，如果p=&s1成立说明两边的类型相同，这两个匿名结构体类型可以认为相同，如果p=&s1出现问题，说明这两个匿名结构体类型是两种不同的类型。
int main()
{
p = &s1;
return 0;
}
我们通过运行代码发现编译器认为这两个匿名结构体类型是两种不同的结构体类型。
1.2 结构体的自引用
在一个结构体中包含一个类型为结构体本身的成员是否可以呢？答案是可以。
那什么时候有在一个结构体类型中包含一个类型为结构体自身的情况呢？答案是链表，当我们后期学习了数据结构的时候会对这个问题理解更深刻，在这里只是简单阐述一下。
我们想要存储一系列的整型数据，可以使用数组，当然也可以使用链表，
上面的结点是一个复杂对象，简单的使用已有的类型无法描述，所以我们需要创建一个结构体类型，一个结点需要有两个信息：数字（int类型）与下一个结点的地址。
struct Node
{
int data;
struct Node* p;
};
1.3 结构体类型重命名
我们在创建一个结构体类型时前面需要加上struct，例如创建一个学生类型时，需要struct Stu s1;这样定义，相对来说比较繁琐，那么有什么简化方法吗？这时候typedef（类型重命名）就显得极为重要了。
未对类型进行重命名时：
struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
};
int main()
{
struct Book b1;
}对结构体类型重命名后：
typedef struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
}Book;
//将struct Book 结构体类型重命名为Book
int main()
{
Book b1; //在定义结构体类型变量的时候不需要再写struct
}注意：在这里我们知道了结构体重命名后再看上面的结点结构体类型很容易就会写成以下代码：
//错误
typedef struct Node
{
int data;
Node* p;
}Node;以上代码是错误的，在结构体里面的struct不能省略，在这里我们还没有完成类型重命名，编译器是无法识别Node的，正确的应该是：
typedef struct Node
{
int data;
struct Node* p;
}Node;1.4 结构体变量的定义和初始化
1.4.1 结构体变量的定义
有了结构体类型，定义结构体变量有三种方式：
1.在声明结构体类型的时候定义变量，注意在这里定义的变量是全局变量。
struct point
{
int x;
int y;
}p1; //声明类型的同时定义变量p1
2.在主函数外定义结构体类型的变量，这里定义的也是全局变量。
struct point
{
int x;
int y;
};
struct point p2;
int main()
{
return 0;
}3.在主函数内部定义结构体类型的变量，在这里定义的变量是局部变量。
struct point
{
int x;
int y;
};
int main()
{
struct point p1;
return 0;
}1.4.2 结构体变量的初始化
初始化（在定义变量的同时赋初值）结构体变量也有两种方式：
全部初始化：
//全部初始化
struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
}s1={"活着","余华",20,"111"};
struct Book s2 = { "李四传","李四",20,"222" };
int main()
{
struct Book s3 = { "王五传","王五",20,"555" };
return 0;
}单独初始化书名和作者：
struct Book
{
char book_name[20];
char author[20];
int price;
char id[15];
}s1 = { .book_name="活着",.author="余华" }; //单独初始化
struct Book s2 = { .book_name = "活着",.author = "余华" };
int main()
{
struct Book s3 = { .book_name = "活着",.author = "余华" };
return 0;
}
除此之外，我们还可以进行结构体嵌套初始化：
struct point
{
int x;
int y;
};
struct Node
{
int data;
struct point p;
struct Node* next;
}s1 = {5,{2,1},NULL};1.5 结构体成员变量的访问
对于结构体成员变量的访问，我们使用 . 或 ->运算符，对于结构体变量的访问，我们在之前的初阶结构体博客中已经详细讲解过，大家可以在之前的博客中查看。
1.6 结构体内存对齐
我们已经掌握结构体内存的基本使用了，现在我们来探讨结构体的大小，注意这也是一个热门的考点：结构体内存对齐。
或许在之前我们会认为结构体类型的大小就是结构体的成员变量的类型大小相加得到的，实际上并不是这样的，我们来简单看一个例题：
struct S1
{
char c1;
int i;
char c2;
};
int main()
{
struct S1 s1;
printf("%d\n", sizeof(struct S1));
return 0;
}
上述代码的运行结果是：
那么为什么会是这样呢？我们通过观察每个成员变量相对开辟空间的起始位置来确定结构体类型在内存中的存放，观察结构体成员相对于起始位置的偏移量我们需要offsetof这个宏。
对于上述的结构体每个成员相对于起始位置的偏移量我们可以使用offsetof这个宏计算出来。
int main()
{
struct S1 s;
printf("%d\n", offsetof(struct S1, c1));
printf("%d\n", offsetof(struct S1, i));
printf("%d\n", offsetof(struct S1, c2));
return 0;
} 
通过上述的偏移量我们可以大致画出此结构体变量在内存中的布局。
1.6.1 结构体的对齐规则
所以结构体在内存中到底是怎么开辟空间的？实际上结构体在内存中开辟空间有以下几点对齐规则：
- 第一个成员在与结构体变量偏移量为0的地址处。
- 其他的成员变量要对齐到某个【对齐数】的整数倍的偏移处。【对齐数】：结构体成员自身大小和编译器默认对齐数的较小值，在vs中默认对齐数是8.
- 结构体的总大小，必须是最大对齐数的整数倍，每个结构体变量都有一个对齐数，其中最大的对齐数就是最大对齐数。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
接下来我们来看几个例题吧！
1.6.2 例题
例题一：
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
struct S2 s2;
printf("%d\n", sizeof(struct S2));
return 0;
}
问题分析：
例题二：
struct S3
{
double d;
char c;
int i;
};
int main()
{
struct S3 s3;
printf("%d\n", sizeof(struct S3));
return 0;
} 
问题分析：
例题三：
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
struct S4 s4;
printf("%d\n", sizeof(struct S4));
} 
问题分析：
1.6.3 为什么存在内存对齐？
1. 平台原因：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
例如：假设32位机器CPU读取时一次读4个字节，
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
1.6.4 建议
在设计结构体的时候，我们既要满足对齐，又要节省空间，这时候我们想到让占用空间小的成员尽量集中在一起的方式。
例如：
struct s1
{
char c1;
int i;
char c2;
}; //结构体的大小是12个字节
struct s2
{
char c1;
char c2;
int i;
}; //结构体的大小是8个字节1.6.5 修改默认对齐数
在上面求结构体的大小时，对齐数使用的很多，在vs编译环境下，默认对齐数是8，但是对于默认对齐数我们也是可以进行修改的。
之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。
#pragma pack(1) //设置默认对齐数是1
struct S2
{
char c1;
int i;
char c2;
};
#pragma pack() //取消设置的默认对齐数，还原为默认结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。
1.7 结构体传参
1.7.1 结构体传参
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);
}
int main()
{
print1(s); //传结构体
return 0;
}结构体传参，形参是实参的一份临时拷贝，会重新开辟空间，空间消耗大，且改变形参的内容不会改变实参。
1.7.2 结构体地址传参
struct S
{
int data[1000];
int num;
};
struct S s = { {1,2,3,4}, 1000 };
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print2(&s); //传地址
return 0;
}传的是结构体的地址，会对结构体造成改变，且消耗空间小。
1.7.3 总结
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
二、位段
2.1 什么是位段？
位段的声明和结构是类似的，有两个不同：
- 位段的成员必须是int、unsigned int或者signed int。
- 位段的成员名后面有一个冒号和一个数字。
我们来通过一个例子来了解位段：
以下的A就是一个位段类型：
//位段-其中的位代表的是二进制位
struct A
{
int _a : 2; //代表_a成员只需要2个bit位
int _b : 5; //代表_b成员只需要5个bit位
int _c : 10; //代表_c成员只需要10个bit位
int _d : 30; //代表_d成员只需要30个bit位
};2.2 位段的内存分配
我们想要知道上面的位段A占内存空间的大小，我们就要知道他在内存中的布局。
对于位段的内存分配有以下几点：
- 位段的成员可以是int unsigned int signed int 或者是char （属于整型家族）类型。
- 位段的空间上是按照需要以4个字节（int）或者1个字节（char）的方式开辟的。
- 位段涉及很多的不确定因素，位段是不跨平台的，注重可移植性的程序应该避免使用位段。
由于位段的不确定因素太多，在c语言标椎中也没有具体规定位段在内存中存储时的具体标准，所以在下面我们先假设位段在vs下的存储，再通过vs中的调试，内存观察是否是这样的存储。
struct S
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
int main()
{
struct S s = { 0 }; //创建一个位段，并把位段的每一个成员都初始化为0
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
return 0;
}
我们按照设想得出了位段的每个成员在内存中的位置，接下来我们通过调试中的内存来看vs编译器中对位段的处理是否与我们预想的相同。
这说明了在vs编译器上，位段在内存中的存储方式与我们设想的一样。
2.3 位段的跨平台问题
由于位段在c语言标准里面没有明确的规定所以位段有很多的不确定性。
- int位段被当做有符号数还是无符号数是不确定的。
- 位段中最大位的数目不能确定（在16位机器最大16,32位机器最大32，写成27在16位机器会出问题）。
-
位段中的成员在内存中从左向右分配，还是从右向左分配标准尚未定义。
-
当一个结构体包含两个位段，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
总结：
和结构体相比，某些情景下位段可以达到相同的效果，可以很好地节省空间，但是有跨平台的问题出现。
三、枚举
枚举就是指一一列举。
在某些情景下，我们已经确定某一事物可能的取值，就可以把可能的取值一一列举。
例如：
一周的每一天可以一一列举。
性别：男、女可以一一列举。
月份也可以一一列举。
3.1 枚举类型的定义
我们首先要了解枚举关键字：enum。
//星期
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.
//颜色
enum Color
{
RED, //默认为0
GREEN, // 1
BLUE // 2
};其次枚举常量也可以赋初值：
//颜色
enum Color
{
RED = 1, //可以给枚举常量赋初始值，但是不能再对枚举常量的值进行改变
GREEN = 2,
BLUE = 4
};不能在后续改变枚举常量的值，编译器会报错：
在这里我们需要注意创建的枚举类型的变量的大小是多少呢？
enum Color
{
RED,
GREEN,
BLUE
};
int main()
{
enum Color color = BLUE;
printf("%d\n", sizeof(color));
}
由于每个枚举常量都是这个枚举变量的一种可能取值，一个枚举变量只会存储其中的一个可能取值，所以他是一个枚举常量的大小。
3.2 枚举的优点
我们为什么要使用枚举，我们可以使用#define定义常量，为什么还要使用枚举？
枚举的优点：
- 增加代码的可读性和可维护性。在这里我们可以参考上一篇博客中通讯录的主函数的实现来更加直观的理解。
- 和#define定义的标识符比较枚举有类型检查，更加严谨。
#define RED 5 #define GREEN 7 #define BLUE 10 // 没有类型，在预处理阶段就会完成替换，不够严谨 int main() { int num = RED; return 0; } -
防止命名污染（封装）。
-
便于调试，如果使用#define无法在调试中检查出问题。
-
使用方便，一次可以定义多个常量。
四、联合（共用体）
4.1 联合体类型的定义
联合也是一种特殊的自定义类型，这个类型定义的变量也包含一系列的成员，特征是这些成员公用同一块空间（所以联合也叫共用体）。
联合体关键字是：union。
//联合类型的声明
union Un
{
char c;
int i;
};
int main()
{
//联合变量的定义
union Un un;
return 0;
}4.2 联合的特点
联合的成员是共用同一块内存空间的，这样一个联合变量的大小，至少是最大成员的大小（因为联合至少得有能力保存最大的那个成员）。
利用这一特点的例题：
判断当前计算机的大小端存储。
我们来回顾一下关于大小端存储的知识：
一个数值，存储时需要的内存空间只要超过1个字节，就涉及顺序的问题。
低位字节的内容放到低地址处，高位字节的内容放到高地址处是小端存储，低位字节的内容放到高地址处，高位字节的内容放到低地址处是大端存储。
例如一个 16进制数 0x11223344：
我们在这里要判断当前计算机是使用的是小端存储还是大端存储，只需要看数据的第一个字节存储内容就可以看出来，在这里为了方便我们使用1来观察。
方法一：
int check_sys()
{
int num = 1;
char* p = (char*)#
if (*p == 1)
return 1;
else
return 0;
}
int main()
{
int ret = check_sys();
if (ret == 1)
printf("小端\n");
else
printf("大端\n");
return 0;
}方法二：
int check_sys1()
{
union Un
{
char c;
int i;
}u;
u.i = 1;
return u.c;
}
int main()
{
int ret = check_sys1();
if (ret == 1)
printf("小端\n");
else
printf("大端\n");
return 0;
}4.3 联合大小的计算
- 联合体的大小至少是最大成员的大小。
- 当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍。
例1：
union Un1
{
char c[5];
int i;
};
int main()
{
printf("%d\n", sizeof(union Un1));
return 0;
}
问题解析：
例题2：
union Un2
{
short c[7];
int i;
};
int main()
{
printf("%d\n", sizeof(union Un2));
return 0;
} 
问题解析：