结构体（详解）
结构体类型的声明
结构是⼀些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量，结构体的声明如下：
struct tag
{
member-list;
}variable-list;下面我们举一个具体的例子： 我们需要创建一个学生的信息表
struct Student
{
char name[20];
int age;
char number[10];
int score;
};我们可以将数据放进去
struct Student stu = { "zhangsan",23,"234556",100 };此外，还可以匿名结构体类型：
struct
{
int a;
char b;
float c;
}x;这个时候大家可能就会问，那如果可以匿名使用结构体类型，为何不都匿名呢，我们可以试着写一段代码跑起来测试：
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20], * p;p=&x;跑起来大家就会发现，编译器会警告，这是因为： 编译器会把上⾯的两个声明当成完全不同的两个类型，所以是⾮法的 所以，在使用匿名结构体类型时，我们只能使用一次！
结构的⾃引⽤
在结构体的使用中，可能大家会问，把结构体存在结构体中是否可以呢 例如：
struct Node
{
int data;
struct Node next;
};答案是不行。仔细分析，其实是不⾏的，因为⼀个结构体中再包含⼀个同类型的结构体变量，这样结构体变量的⼤⼩就会⽆穷的⼤，是不合理的。 但是该如何正确地自引用呢？废话不多说，直接上代码：
struct Node
{
int data;
struct Node* next;
};在结构体自引用中还容易出现一个错误：用typedef对匿名结构体类型重命名，例如
typedef struct
{
int data;
Node* next;
}Node;这样是不行的！ 因为Node是对前⾯的匿名结构体类型的重命名产⽣的，但是在匿名结构体内部提前使⽤Node类型来创建成员变量，这是不⾏的！ 如果要使用typedef应该这样使用：
typedef struct Node
{
int data;
struct Node* next;
}Node;结构体变量的创建和初始化
初始化很简单，不做过多的解释，直接上代码：
struct Point
{
int x;
int y;
}p1; //声明类型的同时定义变量p1
struct Point p2; //定义结构体变量p2
struct Point p3 = {x, y};//初始化：定义变量的同时赋初值。指⽰器初始化⽅式(C99)，这种⽅式允许不是按照成员顺序初始化，也就是说结构体可以这样初始化： 就是不按照结构体内元素的顺序来初始化
struct Stu
{
char name[15];
int age;
};
struct Stu s = {.age=20, .name="zhangsan"};结构成员访问操作符
结构成员访问操作符有两个⼀个是 . ，⼀个是 -> 使用方法如下：
结构体变量.成员变量名
结构体指针—>成员变量名例如：
#include <stdio.h>
#include <string.h>
struct Stu
{
char name[15];//名字
int age; //年龄
};
void print_stu(struct Stu s)
{
printf("%s %d\n", s.name, s.age);
}
void set_stu(struct Stu* ps)//ps的类型是结构体类型的指针，所以可以使用—>
{
strcpy(ps->name, "李四");
ps->age = 28;
}
int main()
{
struct Stu s = { "张三", 20 };
print_stu(s);
set_stu(&s);
print_stu(s);
return 0;
}下面就是结构体的难点了！
结构体内存对⻬
首先我们来了解一下结构体内存的对齐规则：
- 结构体的第⼀个成员对⻬到相对结构体变量起始位置偏移量为0的地址处
- 其他成员变量要对⻬到某个数字（对⻬数）的整数倍的地址处。 对⻬数 = 编译器默认的⼀个对⻬数 与 该成员变量⼤⼩的较⼩值。
- VS中默认的值为8
- Linux中没有默认对⻬数，对⻬数就是成员⾃⾝的⼤⼩
- 结构体总⼤⼩为最⼤对⻬数（结构体中每个成员变量都有⼀个对⻬数，所有对⻬数中最⼤的）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体成员对⻬到⾃⼰的成员中最⼤对⻬数的整数倍处，结构体的整体⼤⼩就是所有最⼤对⻬数（含嵌套结构体中成员的对⻬数）的整数倍
下面我们通过练习来深入了解内存对齐：
struct S1
{
char c1;
int i;
char c2;
};
int main()
{
printf("%d\n", sizeof(struct S1));
}大家可以思考一下问题的答案
正确答案是12！ 为什么呢：我们可以画图来更好的理解 图中蓝色部分就是浪费的空间，黑色是c1的空间，绿色是c2的空间，红色是i的空间 第一步：存放c1 第二步：存放i，i占四个字节，4比8小，故要找4的倍数，找到偏移量为4的地方，往下走占四个字节的空间 第三步：存放c2，一个字节，1比8小，任意数字都是1的倍数，故直接存放在i的下面一个空间
大家可能都以为存放完成了，可能认为答案是9，这是错误的 三个元素的所占空间大小最大的是i，4个字节，所以结构体的大小要是4的倍数，9不是，所以继续往下找最近的一个4的倍数，12是4的倍数，故此结构体的大小是12个字节
那么当结构体内有结构体自引用是的结构体大小又是多少呢： 例如：
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%d\n", sizeof(struct S3));
printf("%d\n", sizeof(struct S4));
}答案是16，32，我们将s3的内存大小求出来后放入s4中遵守同样的内存对齐规则就可以了
为什么存在内存对⻬?
主要原因有两个：
- 平台原因(移植原因)： 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
- 性能原因： 数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。假设⼀个处理器总是从内存中取8个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对⻬成8的倍数，那么就可以⽤⼀个内存操作来读或者写值了。否则，我们可能需要执⾏两次内存访问，因为对象可能被分放在两个8字节内存块中。
简单地来说就是：结构体的内存对⻬是拿空间来换取时间的做法
修改默认对齐数
#pragma 这个预处理指令，可以改变编译器的默认对⻬数，我们用代码来测试一下： 例如：我们将默认内存对齐数改为1
#pragma pack(1)
struct S3
{
double d;
char c;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S3));
}改为1之后结构体大小就变成了13，没改之前的默认对齐数是8，结构体大小为16。 所以，结构体在对⻬⽅式不合适的时候，我们可以⾃⼰更改默认对⻬数
结构体传参
举一个例子：
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);
}
//结构体地址传参
void print2(struct S* ps)
{
printf("%d\n", ps->num);
}
int main()
{
print1(s); //传结构体
print2(&s); //传地址
return 0;
}如果要你调用上⾯的 print1 和 print2 函数，你选择用哪个呢? 答案是：⾸选print2函数。
因为函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。 如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。
所以：结构体传参的时候，最好是传结构体的地址
结构体的位段
下面请看一段代码：
struct A
{
int _a:2;
int _b:5;
int _c:10;
int _d:30;
};大家猜一下结构体A的大小为多少个字节呢？ 答案是8！
大家可以看到，位段更好地节省了结构体的空间 它只给a分配了两个比特位的空间，同理，b为5个比特位，c为10个比特位，d为30个比特位
位段的内存分配
**1. 位段的成员可以是 int unsigned int signed int 或者是 char 等类型 2. 位段的空间上是按照需要以4个字节（ int ）或者1个字节（ char ）的⽅式来开辟的。
就比如说上面我们测试的代码，就是一次性开辟4个字节，a，b共用一个字节，c用两个字节，剩下一个字节不够d用，再开辟4给字节给d，所以结构体A的大小为8个字节
大家要注意： 位段涉及很多不确定因素，位段是不跨平台的，注重可移植的程序应该避免使⽤位段！
好了，结构体的分享到这就结束了，下次再见！