结构体变量的定义和初始化、结构体内存对齐

//5.——————结构体变量的定义和初始化
——定义
方式1
//struct Point
//{
//?? ?int x;
//?? ?int y;
//}p1;//声明类型的同时定义变量p1
方式2
//struct Point
//{
//?? ?int x;
//?? ?int y;
//};
//int main()
//{
//?? ?struct Point p2;//定义结构体变量p2
//?? ?return 0;
//}
——初始化
定义变量的同时赋初始值
//struct Point p3={x,y};
或
//struct Stu//类型声明
//{
//?? ?char name[20];
//?? ?int age[5];
//}s1 = {"wangkai",22};//初始化
//int main()
//{
//?? ?struct Stu s2 = {"zahngjie",20};//初始化
//?? ?return 0;
//}
嵌套结构体的声明
//#include<stdio.h>
//struct Point
//{
//?? ?int n;
//?? ?char ch;
//};
//struct score
//{
//?? ?int n;
//?? ?char ch;
//};
//struct Stu
//{
//?? ?char name[20];
//?? ?int age;
//?? ?struct score s;
//};
//int main()
//{
//?? ?struct Point p2 = {3,4};
//?? ?struct Stu s1 = { "zhangsan",22,{100,'q'}};
//?? ?//s1里包含s，初始化s1时，由于s也是结构体，且结构体初始化要用{}，所以{}嵌套初始化
//?? ?printf("%s %d %d %c\n",s1.name,s1.age,s1.s.n,s1.s.ch);
//?? ?return 0;
//}

//6.————结构体内存对齐
如何计算结构体大小？
首先得掌握结构体的对齐规则：（需画图）
1. 第一个成员在与结构体变量偏移量为0的地址处。偏移量为整数
2. 其他成员变量要对齐到对齐数的整数倍的地址处（可以是1倍）。
? ?对齐数 = 编译器默认的一个对齐数 与 该成员大小中的较小值。（VS中默认的对齐数为8,gcc编译器无对齐数）
? ? 编译器无对齐数默认值时，对齐数就用该成员的对齐数
3. 结构体总大小为最大对齐数（每个成员变量的对齐数进行比较得出的最大的数）的整数倍。
4. 如果处于嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处（不可占用已被使用的对齐数（偏移量）），
? 结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
偏移量计算方法：// 借助宏（macor）,头文件为：<stddef.h>
offsetof()——offsetof(type,member)：可以返回一个结构体成员在这个类型（type）创建的变量中的偏移量
//#include<stdio.h>
//#include<stddef.h>
//struct S1
//{
//?? ?char c1;
//?? ?int i;
//?? ?char c2;
//};
//struct S2
//{
//?? ?char c1;
//?? ?char c2;
//?? ?int i;
//};
//int main()
//{
//?? ?struct S1 s1;
//?? ?struct S2 s2;
//?? ?printf("%d\n",offsetof(struct S1,c1));//0
//?? ?printf("%d\n", offsetof(struct S1, c2));//8
//?? ?printf("%d\n", offsetof(struct S1, i));//4
//?? ?printf("%d\n",sizeof(struct S1));//12
//?? ?printf("%d\n", sizeof(struct S2));//8
//?? ?return 0;
//}
——含嵌套结构体的结构体怎么计算大小？
//struct S1
//{
//?? ?char n;
//?? ?int b;
//?? ?char m;
//};
//struct S2
//{
//?? ?char c;
//?? ?char k;
//?? ?int a;
//};
//struct S3
//{
//?? ?double a;
//?? ?char b;
//?? ?int c;
//};
//struct S4
//{
//?? ?char c1;
//?? ?struct S3 s3;//嵌套一个结构体
//?? ?int i;
//};
//int main()
//{
//?? ?printf("%d\n",sizeof(struct S4));
//?? ?return 0;
//}

为什么存在内存对齐?
1. 平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特
定类型的数据，否则抛出硬件异常。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐（对其边界：对齐数的整数倍）。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。
(假设在32位的环境下，总共为4字节，4*8个比特位。并且计算机一次可以读写4个字节的内容。)
举例说明：
//struct S1
//{
//?? ?char c;//占一个字节
//?? ?int i;//占四个字节
//?? ?int n;//占四个字节
//};
由于每次访问四个字节，所以我们考虑两种存放方法：每个数字便是一次访问，每次四个字节，@：表示空白位置
1.未对齐的存放（紧挨着存放，节省空间，但是浪费时间）： ? ? ? ? ? ? 1.c i1 i2 i3 ? ?2.i4 n1 n2 n3 ?3.n4 @ ?@ ?@
2.已对齐的存放（按照结构体内存对齐要求存放,浪费空间，但节省时间）：1.c @ ? @ ?@ ? ?2.i1 i2 i3 i4 ?3.n1 n2 n3 n4

总体来说：
结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
让占用空间小的成员尽量集中在一起。
//struct S1
//{
//?? ?char c1;
//?? ?int i;
//?? ?char c2;
//};
//struct S2
//{
//?? ?char c1;
//?? ?char c2;
//?? ?int i;
//};
s2更加节省空间