本章重点：

1.结构体

        1.1 结构体类型的声明     

        1.2 结构的自引用

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

        1.4 结构体内存对齐

        1.5 结构体传参

        1.6 结构体实现位段(位段的填充&可移植性)

2.枚举

        2.1 枚举类型的定义

        2.2 枚举的优点

        2.3 枚举的使用

3.联合

        3.1 联合类型的定义

        3.2 联合的特点

        3.3 联合大小的计算

在前期我讲解过一次初始结构体，今天我们仔细讲解自定义类型：

初始结构体链接：

s7——结构体_c语言实现s7协议_wangjiushun的博客-CSDN博客

类型：内置类型和自定义类型

内置类型：语言自身定义的类型，如:char short int……

自定义类型(聚合类型)：结构体，枚举，联合

为什么要有自定义类型？

答:生活中有些(复杂)对象要被描述的话，不能简单使用单个内置类型。

如：

        学生：名字+年龄+性别+成绩

        书：书名+定价+书号等

结构成员用{}聚合在一起，所以也可叫聚合类型。

---

结构体

1. 结构体的声明

1.1 结构体的基础知识

结构是一些值的集合，这些值称为成员变量，结构的每个成员可以是不同类型的。

回顾：成员变量的类型-->结构成员可以是变量、数组、指针，甚至是其他结构体。

vs数组：数组也是一些值的集合，但是这些值的类型是相同的。

1.2 结构的声明

struct tag//①struct结构体关键字，②tag结构体标签名(见明知意)

{

        member-list;//成员列表1~N

}variable-list;//变量列表1~N

//定义学生:名字+年龄//在C语言中：结构体类型是struct+tag，
//在C++中可以直接用tag表示//不使用typedef
struct stu
{char name[20];int age;
}s1,s2;//声明类型的同时定义变量，s1,s2两个结构体变量是全局变量//使用typedef
typedef struct stu
{char name[20];int age;
}stu;//stu不是结构体变量，是结构体类型的别名

注意：结构体使用typedef重命名只能在结构体声明时或声明后，不能在结构体之前重命名(报错:无法解析的外部命令，因为代码是由上到下依次执行的)。

1.3 特殊的声明(使用场景少)

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

匿名结构体：结构在声明的时候省略掉结构体标签(tag)。

注意：只能在声明时使用一次(即只能在声明的同时定义结构体变量，不能在其他地方再使用该结构体创建变量)。

//特殊的声明：
//匿名结构体(不完全声明)：在结构声明的时候省略掉结构体标签(tag)struct
{int a;char b;float c;
}x;struct
{int a;char b;float c;
} * p;int main()
{p = &x;//合法吗？//答：非法的。//警告：虽然两个结构体成员是一样的，但是编译器会把上面两个声明当成两个完全不同的类型//匿名结构体只能使用一次，且是在声明时，该语句相当于又使用一次结构体return 0;
}

1.4 结构的自引用

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

代码1：

//结构的自引用
//在结构中包含一个类型为该结构本身的成员是否可以呢？//代码1struct Node
{int data;struct Node next;
};

思考：代码1可以吗；如果可以，那sizeof(struct Node)是多少？

答：①代码1不可以实现结构的自引用，因为在一个结构体还没有完全定义之前调用该结构体了，C是自上而下编译的，走到struct Node next；这一句的时候，编译器发现struct Node结构并没有定义完整，所以报错。

        ②如果可以，sizeof(struct Node)=4+4+4+……死递归下去，大小就是无限大。

代码2：正确的结构自引用

        正确的结构自引用：定义成结构体的指针，结构的指针不受结构的内容影响，它只是一个指针，指向你定义的一个结构，至于这个结构完不完整是什么，它都不需要知道。因此编译器能令其通过。

        结构体自引用其实就是数据结构中的链表，

如下图，了解即可，后期会详细讲解。

//正确的自引用方式
//代码2struct Node
{int data;struct Node* next;
};

代码3：使用typedef:重命名的别名自引用可以吗

//使用typedef
//代码3typedef struct Node
{int data;Node* next;//这样写可以，可行吗？//答：不可以，报错，编译器找到一个意外标识符，请确保标识符在使用前声明//在结构体自引用时，不能使用结构体的别名，因为代码是由上到下依次执行的
}Node;//结构体类型的别名

代码4：使用typedef时的正确做法

//解决方案
//代码4typedef struct Node
{int data;struct Node* next;//结构体的自引用，使用结构体的本名
};

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

①变量的定义：通过类型创建变量；

②变量的初始化：定义变量的同时赋初值

代码示例：

//结构体变量的定义和初始化struct P
{int x;char ch;
}p1 = { 2, 'a'};//方式①：声明类型的同时定义结构体变量p1(全局的),并初始化struct P p3 = { 3,'b' };//方式②：定义结构体变量p3(全局的)，并初始化struct S
{double d;struct P p2;//结构体嵌套float f;
};int main()
{struct S s = { 3.2,{4,'c'},6.2f };//方式③：定义结构体变量s(局部的)，并初始化struct S s1 = { .f = 3.1f,.p2.ch = 'd',.p2.x = 6,.d = 9.1 };//乱序初始化return 0;
}

1.6 结构体内存对齐

通过前面知识点，我们已经掌握了结构体的基本使用。

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

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

考点：

如何计算？

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

1.结构体的第一个成员，对齐到结构体变量在内存中存放位置的0偏移处。

2.从第二个成员开始，每个成员变量都要对齐到(一个对齐数)的整数倍处。

        ①对齐数=编译器默认的一个对齐数与结构体成员自身大小的较小值。

        ②VS:默认对齐数为8；

           Linux gcc：没有默认对齐数，对齐数就是结构体成员自身大小。

3.结构体总大小，必须是所有成员变量的对齐数中最大对齐数的整数倍。

4.如果嵌套结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数(含嵌套结构体的对齐数)的整数倍。

练习：

案例1：

/结构体内存对齐
//计算结构体内存的大小//案例1：结构体成员个数、类型一样，改变其成员顺序，结构体大小怎么样？#include<stdio.h>struct S1
{char ch1;int i;char ch2;
};struct S2
{char ch1;char ch2;int i;
};int main()
{printf("%d\n", sizeof(struct S1));//12printf("%d\n", sizeof(struct S2));//8return 0;
}

图解：

①struct S1

②struct S2

案例2：

//案例2#include<stdio.h>struct S3
{double d;char ch;int i;
};int main()
{printf("%d\n", sizeof(struct S3));//16return 0;
}

图解：

案例3：结构体嵌套问题

//案例3：结构体嵌套问题#include<stdio.h>struct S3
{double d;char ch;int i;
};struct S4
{char ch1;struct S3 s3;double d;
};int main()
{printf("%d\n", sizeof(struct S4));//32return 0;
}

图解：

 通过这些案例我们知道了计算，但是为什么存在内存对齐呢？

大部分的参考资料都是这么说的：

1.平台原因(移植原因)

        不是所有的硬件平台都能访问任意地址上的任意数据；某些硬件平台只能在某些地址处取某些特定的数据，否则抛出硬件异常(例：int-->对齐到4的整数倍)

2.性能原因

        数据结构(尤其是栈)应该尽可能地在自然边界上对齐。

        原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

图释：

总体来说：

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

那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：

答：让占用空间小的成员尽量集中在一起。

例如：

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

s1和s2类型的成员虽然一模一样，但是s1和s2所占空间的大小有区别。

1.7  查看偏移量与修改默认对齐数

（1）offsetof

1.头文件：“stddef.h”

2.功能：

        在msdn上，该宏被写作：

        size_t offsetof(structName,memberName);

        第一个参数是结构体的名字，第二个参数是结构体成员的名字。该宏返回结构体structName中成员memberName的偏移量。偏移量是size_t类型的。

（2）#pragma pack

程序编译器对结构的存储的特殊处理确实提高CPU存储变量的速度，但是有时候也带来了一些麻烦，我们也屏蔽掉变量默认的对齐方式，自己可以设定变量的对齐方式。

1.#pragma pack(n)来设定变量以n字节对齐方式。（n：可选参数；指定packing的数值，以字节为单位；缺省数值是8，合法的数值分别是1、2、4、8、16。调用pack时不指定参数，n将被设成默认值。）

2.#pragma pack () /*取消指定对齐，恢复缺省对齐,等价于#pragma pack(pop)*/

代码实例：

#include<stdio.h>
#include<stddef.h>#pragma pack(1)//设置默认对齐数为1
struct S1
{char c1;int i;char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认int main()
{//查看偏移量printf("%d\n", offsetof(struct S1, c1));//0printf("%d\n", offsetof(struct S1, i));//1printf("%d\n", offsetof(struct S1, c2));//5//计算结构体的大小printf("%d\n", sizeof(struct S1));//6return 0;
}

图示：

 结论：

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

1.8  结构体传参

先看代码：

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

上面的print1和print2函数哪个好些？

答案是：首选print2函数

原因：

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

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

结论：

结构体传参的时候，最好传结构体的地址。

2.  位段

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

2.1  什么是位段

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

1、位段的成员必须是int，unsigned int或signed int类型。（大量测试，char类型也可以；但是成员的类型通常为相同类型）

2、位段的成员名后边有一个冒号和一个数字。（①位段 - 位：二进制位，②且冒号后面的数字不能大于开辟类型的大小）

例如：

//位段 - 位 ：二进制位struct A
{int _a : 2;int _b : 5;int _c : 10;int _d : 30;
};#include<stdio.h>int main()
{//位段式的结构体A的大小是多少？printf("%d\n", sizeof(struct A));return 0;
}

答：A的大小为8个字节，为什么呢？

2.2  位段的内存分配

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

2、位段的空间上是按照需要以4个字节(int)或者1个字节（char）的方式来开辟的（用多少开辟多少，不够再开辟）

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

图释结构A的大小为什么是8：

再来一个例子：

struct S
{char a : 3;char b : 4;char c : 5;char d : 4;
};#include<stdio.h>int main()
{//s在空间是如何开辟的？struct S s = { 0 };//将s初始化为0便于观察值的变化s.a = 10;s.b = 12;s.c = 3;s.d = 4;return 0;
}

 图示：

 2.3  位的跨平台问题

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

2、位段中最大数目不能确定（int在16位机器最大16,32位机器最大32，写成27，在16位机器会出问题）

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

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

总结：

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

2.4  位段的应用

数据的传输，在数据的传输中我们要将其封装成数据包，如图：

我们看到有许多部分组成，如果我们不使用位段 数据包就较大，网络传输就慢，如果使用位段节省空间数据包小，传输就快了。

3.  枚举

枚举顾名思义就是一一列举。

把可能的取值一一列举。

如我们生活中：

一周的星期一到星期日是有限的7天，可以一一列举。

性别有：男、女、保密，也可以一一列举

月份有12个月，也可以一一列举

这就可以使用枚举。

3.1  枚举类型的定义

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，当然在定义的时候也可以赋初值。

例如：

#include<stdio.h>enum Sex//性别
{//枚举类型的可能取值——枚举常量//默认从0开始，一次递增1MALE,//0FEMALE,//1SECRET//2
};enum Color//颜色
{//枚举常量，在定义是可以赋初值RED = 1,GREEN,BLUE = 5
};int main()
{//打印性别的枚举常量printf("%d %d %d\n", MALE, FEMALE, SECRET);//打印颜色的枚举常量printf("%d %d %d\n", RED, GREEN, BLUE);return 0;
}

运行结果：

3.2  枚举的优点

为什么使用枚举？

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

枚举的优点：

1、增加代码的可读性和可维护性（如我们以前实现的通讯录，选择语句是使用的1,2,3等字面常量，那现在我们可以使用枚举来定义枚举常量实现见名知意）

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

3、防止命名污染（封装）

4、便于调试（#define在预编译时就已经被替换了）

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

3.3  枚举的使用

enum Color//颜色
{RED = 1,GREEN = 2,BLUE = 4
};int main()
{enum Color clr = GREEN;//只能拿枚举常量给枚举变量赋值，才不会出现类型的差异。clr = 5;  //ok??,在VS中虽然不报错，但是是不严谨的，在C++中直接报错return 0;
}

tip：枚举类型的大小与int一样

4.  联合（共用体）

4.1  联合类型的定义

联合也是一种特殊的自定义类型

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

例如：

#include<stdio.h>//联合类型的声明
union Un
{char c;int i;
};int main()
{//联合变量的定义union Un un;//打印联合变量的大小printf("%d\n", sizeof(un));//打印联合变量的起始地址printf("%p\n", &un);//打印联合成员c的起始地址printf("%p\n", &un.c);//打印联合成员i的起始地址printf("%p\n", &un.i);return 0;
}

运行结果：

 

图示：

4.2  联合的特点

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

2、理解：一般联合一次只能使用一个成员不能几个成员共同使用，就像超市的存物柜。

比如：

union Un
{int i;char c;
};#include<stdio.h>int main()
{union Un un;//下面输出的结果是什么？un.i = 0x11223344;un.c = 0x55;printf("%x\n", un.i);return 0;
}

运行结果：

为什么呢？

 因为联合的成员是共用同一块空间的，已经使用了联合成员i赋值11223344，又使用联合成员c赋值55，所以44被55覆盖。（注意：同时使用联合成员并不是将前一个成员的存储空间销毁，而是将前一个成员共用空间的值覆盖；销毁是将存储空间还给操作系统。）

面试题：判断计算机的大小端存储（在之前数据的存储中我们使用指针的方式，现在使用联合方式）

int check_sys()
{union UN{char c;int i;}un;un.i = 1;//0x 00 00 00 01//低地址-------------高地址//01 00 00 00 - 小端（数据的低位放在低地址，高位放在高地址）//00 00 00 01 - 大端return un.c;//小端返回1，大端返回0
}#include<stdio.h>int main()
{if (check_sys()){printf("小端\n");}else{printf("大端\n");}return 0;
}

4.3  联合大小的计算

1、联合的大小至少是最大成员的大小

2、当最大成员大小不是最大对齐数的整数倍的时候，就要对齐到最大对齐数的整数倍（对齐数=编译器默认对齐数与联合成员自身大小的较小值）

比如：

union Un1
{char c[5];int i;
};
union Un2
{short c[7];int i;
};#include<stdio.h>int main()
{//下面输出两个联合的大小printf("%d\n", sizeof(union Un1));//Un1最大成员大小为5，最大对齐数4——>联合大小8printf("%d\n", sizeof(union Un2));//Un2最大成员大小14，最大对齐数4——>联合大小16return 0;
}

自定义类型结构体使用场景多，枚举、联合较少，但是应该在平时多写代码多感悟。