1 结构体的声明
1.1 结构的基础知识
结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。
1.2 结构的声明
1. struct tag 2. { 3. member-list; 4. }variable-list;
例如描述一个学生：
struct是结构体关键字，不能省略。
struct Stu { char name[20];//名字 int age;//年龄 char sex[5];//性别 char id[20];//学号 }s1,s2,s3; //分号不能丢,s1,s2,s3是三个结构体变量
1.3 特殊的声明
在声明结构的时候，可以不完全的声明。
比如：
匿名结构体只能用一次，除非重新创建一个结构体。
//匿名结构体类型 struct { int a; char b; float c; }x; struct { int a; char b; float c; }a[20], * p;
上面的两个结构在声明的时候省略掉了结构体标签（tag）。
那么问题来了？
1. //在上面代码的基础上，下面的代码合法吗？ 2. p = &x;
警告：
虽然两个结构的成员都是一样的，但是编译器会把上面的两个声明当成完全不同的两个类型。
所以是非法的。
那么我们什么时候使用匿名结构体呢？当我们只需要使用一次的时候就可以使用，但不必太依赖。
1.4 结构的自引用
在结构中包含一个类型为该结构本身的成员是否可以呢？当然是可以的，但是不是下面这种方式。
1. struct Node 2. { 3. int data; 4. struct Node n; 5. };
正确的是下面这个代码：
1. struct Node 2. { 3. int data; 4. struct Node* n; 5. };
我们把下个节点的地址保存起来，访问地址就可以找到下一个节点。
1. struct Node 2. { 3. int data; 4. struct Node* n; 5. }; 6. int main() 7. { 8. printf("%d\n", sizeof(struct Node)); 9. return 0; 10. }
总结：结构体内包含一个同类型的结构体是不行的，但是包含一个同类型的结构体指针是可以的。
这种结构体的匿名是不行的，因为这是对这个匿名结构体重命名叫Node，但是还没有重命名的时候就已经在结构体内部使用了Node。
typedef struct { int data; Node* next; }Node;
这才是正确的方法：
1. typedef struct 2. { 3. int data; 4. Node* next; 5. }Node;
1.5 结构体变量的定义和初始化
有了结构体类型，那如何定义变量，其实很简单。
下面这个代码就是在创建结构体变量的时候进行了初始化，p1，p2都是全局变量，p3是局部变量，p3这种初始化方式也是可以的。
struct Point { int x; int y; }p1 = { 1,2 }; struct Point p2 = { 3,4 }; int main() { int a = 30; int b = 20; struct Point p3 = {a,b }; return 0; }
如果我们想不按顺序进行初始化也是可以的，需要使用结构体访问操作符。
struct Stu { char name[15]; int age; }; int main() { struct Stu s1 = { "zhangsan",19 }; struct Stu s2 = { .age=18,.name="xiaozhou"}; printf("%s %d\n", s1.name, s1.age); printf("%s %d\n", s2.name, s2.age); return 0; }
下面这个代码是较为复杂一点的结构体嵌套初始化：
struct Point { int x; int y; }; struct Node { int data; struct Point p; struct Node* next; }n1 = { 10, {4,5}, NULL }; struct Node n2 = { 20, {5, 6}, NULL }; int main() { printf("%d x=%d y=%d\n", n1.data, n1.p.x, n1.p.y); return 0; }
1.6 结构体内存对齐
我们已经掌握了结构体的基本使用了。
现在我们深入讨论一个问题：计算结构体的大小。
这也是一个特别热门的考点： 结构体内存对齐
让我们来看下面这一段代码，s1，s2的成员是一样的，只是顺序的不同，那么它们各自所占内存大小是多少呢？
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; }
结果是大小不相同，为什么呢？
这里给大家介绍一个宏-offsetof，可以直接使用，原来计算结构体成员相较于起始位置的偏移量。
假设我们创建一个结构体struct S1 s1，假设从0这个位置开始，那么0这个格子的字节相较于起始位置的偏移量就是0，相较于起始位置偏移了几个字节，偏移量就是几。
那么S1的成员c1占1个字节，i占4个字节，c2占1个字节，为什么算出来是12个字节呢？
那么S2的成员c1占1个字节，i占4个字节，c2占1个字节，为什么算出来是8个字节呢？
我们使用offsetof计算一下，记得要包含头文件stddef.h。
那么0，4，8是什么意思呢？就是第一个成员c1的偏移量是0，就占开始的1个字节，第二个成员i的偏移量是4，由于类型是int，从4这个位置开始向后占4个字节，第三个成员c2的偏移量是8，由于类型是char，从8这个位置开始向后占1个字节.那么一共占9个字节就存放完了，那么后面有3个字节也是开辟给了S1，和前面空着的那3个字节属于是浪费的.
我们再看一下S2，第一个成员c1的偏移量是0，就占开始的1个字节，第二个成员c2的偏移量是1，由于类型是char，从1这个位置开始向后占1个字节，第三个成员i的偏移量是4，由于类型是int，从4这个位置开始向后占4个字节.那么一共占8个字节就存放完了.中间两个字节开辟出来也浪费掉了。
为什么要出现这种浪费空间，这就是内存对齐的知识。
如何计算？
首先得掌握结构体的对齐规则：
1. 第一个成员在与结构体变量偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的值为8
3. 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
struct S1 { char c1; int i; char c2; }; struct S2 { char c1; char c2; int i; };
S1和S2类型的成员一模一样，但是S1和S2所占空间的大小有了一些区别。
那么具体是怎么对齐的呢？我来给大家举两个例子：
1. struct S3 2. { 3. double d; 4. char c; 5. int i; 6. };
d占8个字节，所以从0开始就是0-7，c占1个字节，vs的对齐数是8，默认对其数就是1，所以从8开始占1个字节，刚好就是8这个空间，i的对齐数就是4了，4的最小整数倍是12，所以从12开始占4个字节，9，10，11这块空间就浪费了，这个结构体从0-15就是16个字节，那么16是不是最终大小呢？这个结构体的最大对其数是8，1，4中的8，8的倍数刚好是16，所以就是16了。
还有一种特殊的情况就是嵌套了一个结构体：
1. struct S4 2. { 3. char c1; 4. struct S3 s3; 5. double d; 6. };
c1占1个字节，所以就占0这块空间，S3这个结构体的最大对齐数是8，从8-23占16个字节，d占8个字节，对齐数是8，8的倍数刚好是24，从24-31占8个字节，所以S4这个结构体的最大对其数就是8，8的最小倍数就是32，那么大小就是32.
为什么存在内存对齐?
1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访
问。
假设有一个结构体struct S s，如果是不对齐就是上面这种情况存放，如果是在32位机器上，读取数据一次拿取32位的数据，所以第一次只能拿走i的3/4，剩下的要进行第二次读取。
如果是对齐就是下面这种情况存放，如果是在32位机器上，读取数据一次拿取32位的数据，所以第一次读取c和后面的3个字节，第二次读取完整的i。
总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起。
1.7 修改默认对齐数
之前我们见过了 #pragma 这个预处理指令，这里我们再次使用，可以改变我们的默认对齐数。
#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #pragma pack(8)//设置默认对齐数为8 struct S1 { char c1; int i; char c2; }; #pragma pack()//取消设置的默认对齐数，还原为默认 #pragma pack(1)//设置默认对齐数为1 struct S2 { char c1; int i; char c2; }; #pragma pack()//取消设置的默认对齐数，还原为默认
结论：
结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。
1.8 结构体传参
如果我们想要将一个结构体的内容进行打印，将这个结构体名称传参就行了，这种属于传值调用。
struct S { int data[1000]; int num; }; void print(struct S s) { printf("%d %d %d %d", s.data[0], s.data[1], s.data[2], s.num); } int main() { struct S s = { {1,2,3},100 }; print(s); return 0; }
如果s这个结构体过大，传过去既浪费了时间也浪费了空间，效率不高，更好的方法是传址调用。
struct S { int data[1000]; int num; }; void print(struct S* s) { printf("%d %d %d %d", s->data[0], s->data[1], s->data[2], s->num); } int main() { struct S s = { {1,2,3},100 }; print(&s); return 0; }
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
