目录
一.结构体类型的声明
(1)结构体的声明
(2)结构体的创建和初始化
(3)匿名结构体
(4)结构体的自引用
二.结构体内存对齐
(1)对齐规则
(2)为什么存在内存对齐？
(3)结构体传参
三.结构体实现位段
(1)什么是位段
(2)位段的内存分配
(3)位段的跨平台问题
一.结构体类型的声明
(1)结构体的声明
struct tag
{
member-list;
}variable-list;结构体是一些值的集合，这些值称为成员变量。结构体的每一个变量可以是不同的类型。
例如使用结构体描述一个学生：
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
};//这里可以不写(2)结构体的创建和初始化
#include<stdio.h>
struct Stu
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
};//这里可以不写
int main()
{
struct Stu s1 = { "张三",18 ,"男"};
//结构体成员的初始化要按顺序进行。
// struct Stu s1 = { "张三","男"，18};
//这样就是不行的。
printf("%s ",s1.name);
printf("%d ",s1.age);
printf("%s ",s1.sex);
printf("\n");
//也可以指定进行初始化
struct Stu s2 = {.age = 18,.name = "李四",.sex = "女"};
printf("%s ", s2.name);
printf("%d ", s2.age);
printf("%s ", s2.sex);
return 0;
}(3)匿名结构体
在声明结构体的时候，可以不完全的声明。
struct
{
int a;
char b;
float c;
}x;
struct
{
int a;
char b;
float c;
}a[20], * p;这两个结构体就省略掉了结构体标签（tag）
那么问题来了？
第一个结构体和第二个结构体的成员变量都是一模一样的。
p = &x;这个代码是否有问题？
warning C4133: “=”: 从“*”到“*”的类型不兼容
编译器会发生警告，这两个结构体是不同的类型，所以是非法的。
匿名的结构体类型，如果没有对结构体类型进行重命名的话，基本上是只能使用一次。
(4)结构体的自引用
在一个结构体中包含一个类型为结构体本身的成员是否可以呢？
比如定义一个链表的节点：
struct Node
{
int val;
struct Node next;
};上面的代码正确吗？
结构体的大小应该是固定的，一个结构体包含自己和另一个整形变量，这肯定是不合理的，这样的变量会无穷大。正确的自引用应该是包含一个结构体指针指向下一个结构体。
typedef struct
{
int val;
Node* next;
}Node;这个代码可行吗？
答案是不行的，因为Node是对前面的匿名结构体进行了重命名，但是在匿名结构体内存提前使用了Node类型的变量来创建成员变量，这是不行的。
所以在定义结构体的过程中尽量不要使用匿名结构体。
二.结构体内存对齐
我们已经掌握了结构体的基本使用，现在我们可以深入讨论一个问题：结构体的大小？
#include<stdio.h>
struct s1
{
int a;
char b;
};
struct s2
{
char a;
int b;
char c;
};
int main()
{
printf("%zd\n",sizeof(struct s1));
printf("%zd\n",sizeof(struct s2));
return 0;
}思考一下s1和s2所占字节是多少？
输出结果：
struct s1的大小是8个字节，为什么不是4（int）+ 1(char)=5个字节呢？？？
同理为什么struct s2不是6个字节呢？
说明在这个结构体中内存是存在一定的浪费的。
(1)对齐规则
偏移量就是距离结构体第一个字节的距离，第一个字节的偏移量是0，第二个偏移量是1，同理依次类推。
struct s1
{
int a;
char b;
};我们先来计算这个结构体的大小。
规则1：就是结构体的第一个成员要放在最前面的位置
也就是int占据前4个字节。
什么是对齐数呢？
除了第一个成员变量之外，其他的结构体成员是需要对齐到某个数字开始存储的。
在vs2022中的对齐数是8，在Linux，gcc中是没有默认对齐数的，对齐数是成员自身的大小。
对齐数 = 编译器默认的一个对齐数和该成员变量大小的较小值
例如在vs2022中 char的对齐数就是 1 （1 < 8）;int 的对齐数就是4 (4 < 8);
讲解完了对齐数，回到上面那个问题。
第二个成员变量char 是要对齐到它的对齐数的整数倍处。而任何数都是1的整数倍，所以char就放在int的后面即可。
第三条规则：结构体的总大小为最大对齐数的整数倍。
最大对齐数是所有结构体成员变量的对齐数的最大值。
通过前两个规则我们知道， char的对齐数就是 1 （1 < 8）;int 的对齐数就是4 (4 < 8)，所以最大对齐数是4;而且已经占据了5个字节，但是并不是4的整数倍，所以这个结构体的大小要自动补齐到八个字节。
所以这个结构体的大小是8个字节。
那么我们现在来计算struct s2 的字节
struct s2
{
char a;
int b;
char c;
};第一个结构体成员变量发在第一个字节，而第二个结构体成员int对齐到4的整数倍处也就是从偏移量4的字节开始占据4个字节，然后第三个结构体成员变量char对齐1的整数倍处，也就是偏移量8的字节，最大对齐数是4，根据第三条规则结构体的大小就应该是4的整数倍，也就是12了。
结构体嵌套问题
我们把结构体struct s2 改变一下，
struct s1
{
int a;
char b;
};
struct s2
{
char a;
int b;
char c;
struct s1 d;
};那么此时的struct s2 的大小是多少？
规则4：嵌套的结构体要对齐到该结构体成员变量中最大对齐数的整数倍处。
结构体s1的最大对齐数是4，所以d应该对齐到4的整数倍处
这时候已经占据了20个字节，再根据规则三:整个结构体的最大对齐数4，而20刚好是4的倍数，所以不再变大了，这个结构体的大小就是20.
#include<stdio.h>
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%zd\n", sizeof(struct S3));
printf("%zd\n", sizeof(struct S4));
}struct s3:
不难推断处结构体s3的大小是16；
结构体s3的最大对齐数是8，故对齐到偏移量为8的位置，大小16个字节。s4的 最大对齐数就是8，也要对齐，刚好32就是8的倍数，所以这个结构体的大小就是32；
(2)为什么存在内存对齐？
- 平台原因：
不是所有的硬件平台都能够访问任意的地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定的类型的数据，否则会抛出硬件异常。 - 性能原因：
数据结构（尤其是栈）应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要进行两次内存的访问；而对齐的内存访问只需要一次。假设一个处理器总是从内存中取八个字节，则地址必须是8的倍数。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作做来读或者写值了。否则，计算机可能需要执行两次内存访问，因为对象可能会被分放在两个8字节的内存块中。
总结：结构体内存对齐是拿空间来换取时间的做法。
那么在我们设计结构体时候，我们既要满足对齐，又要尽可能的节省空间
struct S
{
char a;
int b;
char c;
};
struct S
{
char a;
char c;
int b;
};我们发现第二个结构体的大小明显小于第一个。
让占用空间小的成员尽可能的集中在一起。
(3)修改默认对齐数
#pragma这个预处理指令可以修改编译器的默认对齐数
#include<stdio.h>
#pragma pack(1)//将默认对齐数设置为1
struct S3
{
double d;
char c;
int i;
};
struct S4
{
char c1;
struct S3 s3;
double d;
};
int main()
{
printf("%zd\n", sizeof(struct S3));
printf("%zd\n", sizeof(struct S4));
}再次运行代码我们就会发现结果已经不一样了。
#pragma pack()再加上这个就可以取消对齐数，还原为默认值。
结构体在对齐方式不合适的时候，我们就可以自己更改默认对齐数。
(3)结构体传参
#include<stdio.h>
struct S
{
int arr[1000];
int n;
double d;
};
void print1(struct S tmp)
{
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", tmp.arr[i]);
}
printf("%d ", tmp.n);
printf("%lf\n", tmp.d);
}
void print2(const struct S* ps)
{
int i = 0;
for (i = 0; i < 5; i++)
{
printf("%d ", ps->arr[i]);
}
printf("%d ", ps->n);
printf("%lf ", ps->d);
}
int main()
{
struct S s = { {1,2,3,4,5}, 100, 3.14 };
print1(s);
print2(&s);
return 0;
}观察print1和print2函数，这两个函数都是在打印这个结构体，那么这两个结构体有什么区别呢？或者他们两个哪一个更好？
答案是print2函数
函数传参的时候，参数是需要压栈的，会有时间和空间上的系统开销。
如果传递一个结构体对象的时候，结构体过大，参数压栈的系统的开销比较大，所以会导致性能下降。
所以为了避免这样的情况，结构体传参的时候，要传结构体的地址。
三.结构体实现位段
不是段位 
(1)什么是位段
位段的声明和结构是类似的，有两个不同：
- 位段的成员必须是int 或者unsigned int或者signed int ,在C99中位段成员的类型也可以选择其他类型
- 位段的成员名后面后一个冒号和一个数字。
struct A
{
int a:2;
int b:5;
int c:10;
int d:30;
};A就是一个位段类型
那么位段A所占内存的大小是多少？
答案是8.为什么呢？
变量名的后面跟着一个冒号数字代表这个数字只占多少个bit位。
比如int c:10,表示这个c变量占据了10个bit位。
而我们知道正常的一个int类型的变量是4个字节，占据32个bit位。
所以这样位段可以节省内存。
首先分配4个字节的空间存储a,还剩30个bit，然后在把b放进去，还剩25个bit，再把c放进去，只剩15个bit了不够容纳d了，所以再分配4个字节的空间，然后把d放进去。总共使用了8个字节，所以这个结构体的大小是8个字节。
(2)位段的内存分配
struct S
{
char a : 3;
char b : 4;
char c : 5;
char d : 4;
};
int main() {
struct S s = { 0 };
s.a = 10;
s.b = 12;
s.c = 3;
s.d = 4;
}
在vs2022上，申请到的一块空间是从右向左使用的。但是不同的平台这是不确定的。
10的二进制是1010，但是a只有3位，所以存入010，
12的二进制是1100，b有4位，存入1100
3的二进制是0011，c有5位存入0011
4的二进制0100，存入0100
所以从低到高，十六进制0x62 0x03 0x04，总共占据三个字节
(3)位段的跨平台问题
- int位段被当成有符号数还是无符号数是不确定。
- 位段中的最大位数是不能确定的。（16位机器最大是16，32位机器最大32，写成27，在16位机器就会出问题）
- 位段中的成员在内存中从左向右，还是从右向左分配这个是标准为定义的。
- 当一个结构体包含两个位段的时候，第二个位段成员比较大，无法容纳第一个位段剩余的位时，是舍弃剩余的位还是利用，这是不确定的。
总的来说：更结构体相比，位段可以达到同样的效果，并且可以很好的节省空间，但是有跨平台的问题存在。
(4)位段使用的注意事项
位段的成员共有一个字节，这样有些成员的起始地址并不是某个字节的起始位置，那么这些位置处是没有地址的，内存中的每一个字节分配一个地址，一个字节内部的bit位是没有地址
所以不能使用取地址操作符&利用scanf直接给位段的成员输入值，只是先输入放在一个变量中然后赋值给位段的成员。
#include<stdio.h>
struct A
{
int _a : 2;
int _b : 5;
int _c : 10;
int _d : 30;
};
int main()
{
struct A sa = { 0 };
//scanf("%d", &(sa._b));//这是错误的
//正确的示范
int b = 0;
scanf("%d", &b);
sa._b = b;
return 0;
}
