1. 前言

在C语言中已经为用过户提供了内置类型，如：char，short，int，long等等，但是仅仅只有这几种类型是远远不够的，并不能满足用户的需求，当用户描述的对象很复杂（属性较多）时，如一个学生，一本书，这时单一的内置类型是不行的。在前面的数据结构中已经体会到了单一内置类型的不足。而C语言为了解决这个问题，增加了结构体这种自定义的数据类型（何为自定义类型 —— 根据需要，用户自己来设计的一种类型），让用户可以自己创造适合对象的类型。

2. 结构体

2.1 结构体的声明

使用结构体时需要用到结构体的关键字 —— struct。什么是结构呢？结构是一些值的集合，这些值被称作成员变量，结构的每个成员可以是不同类型的的变量，如：标量，数组，指针，甚至是其它结构体。那么如何去声明一个结构体？如下所示：

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

tag —— 结构体标签的名字，根据用户的需要去设计，与变量的变量名设计一致
member-list —— 结构体的成员列表，存在一个或多个成员
variable —— 结构体的变量列表，可以省略不写
注意：结构体末尾存在一个分号

下面就来声明一个书这样的结构体类型 —— 属性有书名，作者，价格等等：

struct book
{char name[20];   // 书名char author[20]; // 作者double price;    // 价格
};

这样我们就声明了一个书结构体类型。

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

有了结构体的声明之后，就可以使用这个结构体的类型了，如何使用呢？—— 结构体类型就是一个模具，声明出了结构体类型后，就可以定义出结构体类型的变量，定义方式：struct 结构体名字 + 变量名。如下所示：

struct book book1;
struct book book2;

book1 和 book2 就是结构体变量，结构体变量可以是局部变量也可以是全局变量。全局变量不仅仅可以直接创建在局部域当中，也可以在结构体声明的同时创建结构体变量，如下所示：

struct book
{char name[20];   // 书名char author[20]; // 作者double price;    // 价格
}book5, book6; // 全局变量//全局变量
struct book book3;
struct book book4;int main()
{//局部变量struct book book1;struct book book2;return 0;
}

变量定义完毕后，需要对结构体变量里的成员初始化，怎么初始化呢？
首先初始化是在一个大括号里，初始化的顺序可以与结构体的声明中成员的顺序不一致，但是最好是一致的，不一致的需要额外的操作。
具体初始化方式如下：

初始化顺序与结构体声明中的成员的顺序一致：

struct book book1 = { "老鹰抓小鸡", "埃伊蟹黄面", 88.8 };
struct book book2 = { "小鸡自卫战", "埃伊蟹黄面", 99.9 };

初始化顺序与结构体声明中的成员的顺序不一致：

struct book book3 = { .author = "埃伊蟹黄面", .name = "小鸡吃老鹰", .price = 77.7 };
struct book book4 = { .price = 109.8, .name = "小鸡变老鹰", .author = "埃伊蟹黄面" };

需要用到 . 操作符来访问具体的成员变量。
之前有提到过，结构体的成员类型不仅可以是基础的内置类型，也可以是结构体类型，那么当结构体中存在另一个结构体类型时，又该怎么初始化呢？如下所示：

struct other
{char character;int rint;float rfloat;
};struct book
{char name[20];   char author[20]; struct other ther;double price;
};int main()
{struct book book5 = { "ppt", "ptr", { 'G', 68, 53.2 }, 9.9 };return 0;
}

结构体类型的成员变量的初始化也需要用另外的大括号括起。既然初始化完毕，我们可以尝试将这些初始化值打印出来，但是结构体中有这么多的成员变量怎么找到要打印的变量呢？可以通过 . 操作符来访问具体的成员变量 ，访问方式为：结构体的名字.要访问的变量的名字，如下所示：

struct book book5 = { "ppt", "ptr", { 'G', 68, 53.2 }, 9.9 };//单独访问
printf("%s\t", book5.name);
printf("%s\t", book5.author);
printf("%.2f\t", book5.price);
printf("%c\t", book5.ther.character);
printf("%d\t", book5.ther.rint);
printf("%.2f\n", book5.ther.rfloat);//一起访问
printf("%s\t%s\t%.2f\n", book5.name, book5.author, book5.price);
printf("%c\t%d\t%.2f", book5.ther.character, book5.ther.rint, book5.ther.rfloat);

运行结果：

初始化的值并不是一成不变，在初始化后，可以对自己想要改变的变量的值进行修改，具体如下：

struct book book5 = { "ppt", "ptr", { 'G', 68, 53.2 }, 9.9 };
book5.price = 99.9;
book5.ther.character = 'H';
strcpy(book5.name, "小鸡的独立");

修改后，代码的运行结果：

由上图可知，结构体中变量的值被修改了。

2.3 结构体的特殊声明

在声明结构体的时候，可以不完全的声明，之前的结构体的声明是完全的结构体声明。不完全的结构体的声明是怎样的呢？如下代码所示：

struct
{int id;char name[20];int age;double high;
};

上面的代码就是不完全的结构体的声明，省略了结构体的名字，所以这种结构体也称为匿名结构体。将结构体写成匿名结构体后，结构体变量的创建的就只能在声明的同时创建，因为这个结构体没有标签（名字）呀，怎么在局部域中创建？具体创建方式如下所示：

struct
{int id;char name[20];int age;double high;
}stu1, stu2;

对于匿名结构体类型，如果没有对结构体类型重命名的话，基本上只能使用一次。

2.4 结构体的自引用

结构体的自引用是什么意思呢？—— 结构体中包含一个或多个类型为该结构体本身类型的成员变量。数据结构中经常用到，如单链表的结点的结构体：

struct SListNode
{int data;struct SListNode* next;
};

上面的就是结构体的自引用。在结构体的自引用当中可以使用typedef关键字对结构体进行重命名，如下所示：

typedef struct SListNode
{int data;struct SListNode* next;
}SLNode;

之后SLNode就相当于是struct SListNode，既然如此，能不能将结构体内部的struct SListNode* 替换成 SLNode* 呢？不能！因为SLNode是对前面的结构体类型重命名产生的，它是后于结构体类型创建的。

2.5 结构体的内存对齐

结构体既然是个自定义类型，那么该类型的内存大小又是多少呢？不同的结构体类型中的成员变量的类型不同，成员变量的个数不同会对结构体是内存大小产生影响，而要想知道怎么不通过sizeof来计算结构体类型的大小，就得要了解结构体内存对齐。
在介绍结构体内存对齐前，来计算以下两个结构体的大小：

在不了解结构体内存对齐之前，计算的方法可能是这样：对于Test1结构体，第一个成员类型为char，所以该成员变量的内存大小为1个字节，以此类推，所以Test1结构体的内存大小一共为6个字节；对于Test2结构体，第一个成员类型为char，所以该成员变量的内存大小为1个字节，以此类推，所以Test2结构体的内存大小一共为6个字节。那么这样的计算逻辑有没有问题呢？接下来用sizoef来计算两个结构体类型的大小：

为什么得到的结果不是两个6，而是Test1的内存的大小为8个字节，Test2的内存大小为12个字节呢？因为结构体的成员在存储的时候会存在内存对齐现象。该现象涉及到了结构体当中的偏移量，何为偏移量，距离起始位置相差多少个字节就为多少偏移量，具体如下所示：

明白了偏移量是什么后。接下来开始介绍结构体内存对齐的规则：

1. 结构体的第一个成员变量对齐到和结构体变量的起始位置偏移量为0的位地址
2. 其它的结构体成员变量要对齐到某个数字（对齐数）的整数倍地址处
对齐数 = 编译器默认的一个对齐数 与 该成员变量大小的较小值
在编译器中，vs编译器中默认对齐数为 8
Linux中 gcc 没有默认对齐数，对齐数就是成员自身类型的大小
3. 结构体总大小为最大对齐数（结构体中每个成员变量的对齐数中的最大值）的整数倍
4. 如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是最大对齐数（含嵌套结构体中的成员的对齐数）的整数倍

知道了结构体内存对齐的规则之后，接下来根据该规则计算先前的两个结构体类型的大小：

Test1结构体的内存大小计算：

Test2结构体的内存大小计算：

当要计算的结构体中又嵌套了一个结构体呢？这该如何计算？接下来就来详细的计算嵌套结构体类型的内存大小：

接下来用sizeof来计算Test2结构体的内存大小：

了解了内存对齐的运用之后，接下来思考为什么会存在内存对齐呢？有以下几个原因：

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

在前面又计算过两个成员类型相同，成员个数相同的结构体，但是计算的结果却不一样，如下图所示：

这表明了在设计结构体的时候，让占用空间小的成员尽量集中在一起，这样就可以最大限度的节省空间。

2.6 修改默认对齐数

其实vs编译器的默认对齐数8是可以修改的，#pragma这个预处理指令就可以修改编译器的默认对齐数。具体修改方法如下：

#pragma pack(2) // 设置默认对齐数为2
struct Test3
{char charc1;int rint;char charc2;
};
#pragma pack() // 取消设置的默认对齐数

下面与未修改默认对齐数的结构体的内存大小进行比较：

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

2.7 结构体传参

结构体既然作为自定义类型，自然可以用作函数的参数。它与内置类型传参的一致，又传值传参和传址传参。下面来分别写成结构体的传值传参和传址传参。

传值传参：

若想要访问结构体对象中的成员，可以通过 . 操作符 来访问。

传址传参：

若想要访问结构体对象中的成员，可以通过 ->操作符 来访问。

无论是传值传参还是传址传参，都满足我们的要求，那么到底哪种传参方式更好一些呢？选择传址传参会更好一些，为什么呢？函数传参的时候，参数是需要压栈的，这样就会有时间和空间上的系统开销；如果传递一个结构体对象的时候，结构体过大，参数压栈的系统开销比较大，会导致性能的下降。所以结构体传参时，要传结构体的地址。

3. 位段

位段的声明与结构体是类似的，但是存在着两个不同：

1. 位段的成员类型可以是 int ， unsigned int 或 signed int ，char ，在C99中位段成员的类型也可以选择其它的类型
2. 位段的成员后面又一个冒号和数字

具体的声明如下代码所示：

struct Digital
{int m_a : 2;int m_b : 5;int m_c : 10;int m_d : 30;
};

Digital 就是一个位段。位段中的成员的冒号后面的数字是该成员变量的大小，单位是 bit ，该数字的大小不能超过成员的类型的大小，如成员的类型为 int 类型，那么该成员冒号后面的数字不能超过32。那么这个位段的大小是多少呢？又该怎么计算呢？哎！想要知道这些，就得要了解位段的内存分配：

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

根据位段的内存分配方式，来计算下面位段的大小：

struct Number
{char a : 3;char b : 4;char c : 5;char d : 4;
};int main()
{//将num对象中的所有比特位都赋值为0struct Number num = { 0 };num.a = 10;num.b = 12;num.c = 3;num.d = 4;return 0;
}

大概的来推算一下，该位段的大小。前面有提到过，位段的空间是是按照4或1个字节的方式开辟的，这个位段的成员类型大多是char类型，所以开辟空间的方式每次开辟1个字节，不够了再开辟1个字节。
首先为变量a开辟一个字节大小的空间，变量只有3bit大小，剩下5bit未被使用；接着存储变量b，变量的大小有4bit大小，而之前为变量a开辟的剩下的空间为5bit，所以不需要再次开辟空间，剩下的5bit空间足够存储变量b，这样就剩下一个bit大小的空间；
接着存储变量c，变量c有5bit大小，剩下的空间只有1bit大小，所以需要再次开辟1个字节大小的空间，第一次开辟的空间的剩余部分被舍弃，那么变量c就直接占用新开辟的空间的5bit大小空间，剩下3bit未被使用；
接下来再来存储变量d，变量d有4bit大小，但是剩下的空间只有3bit大小，所以需要再次开辟1个字节大小的空间，那么剩下的3bit大小的空间按照之前的假设，直接舍弃。
所以按照上面的推算位段Number的大小为3个字节。

但是还有另外一种推算方法就是剩下的空间不被舍弃，那么按照此推算方法，位段Number的大小为2个字节。

在当前环境下，结果到底是2个字节还是3个字节，用 sizeof 一求便知，结果如下：

根据结果易知，在vs编译器下推算1的方法正确。

前面有提到位段是不支持跨平台的，由于它有许多的不确定的因素，那么这些不确定的因素有：

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

既然位段有这么多的缺陷，那么它还有什么运用场景呢？位段可以运用于网络协议中，这里使用位段不仅能够实现想要的效果，还能节省空间，这样网络传输的数据包大小也会较小一些，对于网络的通畅有帮助。

在使用位段时，还需要注意：位段的几个成员共有同一个字节，这样有些成员的起始位置并不是某个字节的起始位置，那么这些位置处是没有地址的。内存中每个字节分配一个地址，而一个字节的内部的bit位是没有地址的。所以不能对位段的成员使用&操作符，如此一来就不能通过
scanf 直接给位段的成员输入值，只能是先输入一个值，并将该值放在一个变量中，然后赋值给位段的成员。

具体如下所示：

struct Digital dig = { 0 };
//错误方法 —— scanf("%d", &dig.m_a);//正确方法
int a = 0;
scanf("%d", &a);
dig.m_a = a;

4. 联合体

如同结构体一致，联合体也是由一个或者多个成员构成，这些成员可以是不同的类型，但是编译器只为最大的成员分配足够的内存空间。联合体也有它的关键字 —— union。联合体的特点是所有的成员都共用同一块内存空间，所以联合体也称为：共用体。给联合体当中的某个成员赋值，其它的成员也会跟着变化。下面来使用联合体：

如何计算联合体的大小？

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

接下来用具体的例子来明白如何计算联合体的大小：

联合体中也存在内存对齐，该联合体的最大对齐数为4，而该联合体中最大成员的大小为5，不是最大对齐数的整数倍，浪费3个字节大小的空间，所以 Un1 联合体的大小为8个字节。

下面使用联合体来判断当前机器是大端还是小端：首先来介绍何为大端和小端，如下图所示：

下面开始编写代码：

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

利用了联合体的一个特点：所有的成员都共用同一块内存空间，给联合体当中的某个成员赋值，其它的成员也会跟着变化。具体的分析如下：

5. 枚举

枚举枚举，顾名思义就是一一列举，把可能的值一一列，在日常生活中，天数可以被一一列举，月份可以被一一列举等等，而这些数据就可以使用枚举。枚举就是用来表示那些取值可以被一一列举的类型。枚举的关键字是 —— enum。枚举类型的使用：

//枚举类型的声明
enum Day
{//枚举类型的可能取值//这些可能取值都是常量，并且它们都是有值的//默认从 0 开始，依次递增 1Mon,Tues,Wed,Thur,Fri,Sat,Sun
};int main()
{//枚举类型的定义enum Day day = Sun;//打印枚举类型Day的所有可能取值printf("%d\t", Mon);printf("%d\t", Tues);printf("%d\t", Wed);printf("%d\t", Thur);printf("%d\t", Fri);printf("%d\t", Sat);printf("%d\t", Sun);return 0；
}

打印结果：

枚举类型中的常量是可以在声明的同时赋初始值的，也就是给常量初始化，如下所示：

有人可能会有疑问，既然是定义常量，为什么要使用枚举这个类型呢？#define也可以定义常量呀？也就是说，枚举有什么优点？枚举常量的优点有很多：

1. 增加代码的可读性与可维护性
2. 和#define定义的标识符比较枚举有类型检查，更加严谨
3. 便于调试，预处理阶段会删除#define定义的符号
4. 使用方便，一次可以定义多个常量
5. 枚举常量是遵循作用域规则的，枚举声明在函数内，就只能在函数内使用

6. 结言

以上就是C语言中主要的自定义类型。其中最主要的是结构体类型，在学习C++时，遇到的类与结构体有着相似之处。学好它，有助于理解C++中的类类型。