远看山有色，近听水无声。春去花还在，人来鸟不惊。 — 唐代·王维《画》
这篇博客我们会详细介绍结构体相关知识，干货满满。
结构体的声明🍀
一般来说结构体应该有成员列表和变量列表这两个基础的模式。
例如描述一个学生：
struct strudent
{
char name[20];//名字
int age;//年龄
char sex[5];//性别
char id[20];//学号
}; //分号不能丢
当然也不是只有这一种声明。
特殊的声明🐽
在声明结构的时候，可以不完全的声明。
比如：
//匿名结构体类型
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;
};
//可行否？
//如果可以，那sizeof(struct Node)是多少？
当然是不可以，struct Node next永远都还有下一个struct Node next，这样怎么可以呢？
正确的自引用方式：
//代码2
struct Node
{
int data;
struct Node* next;
};
注意：
typedef struct
{
int data;
Node* next;
}Node;
//这样写代码，可行否？
不行 首先这个匿名结构体，重定义为Node,但是重定义之前，就定义了Node*next，
这个不被允许的！
解决方案：
typedef struct Node
{
int data;
struct Node* next;
}Node;
还有数据结构中常见的写法
typedef struct Node
{
int data;//数据
struct Node* next;//指针
} Node, * pNode;
//pNode --> struct Node*
结构体变量的定义和初始化 🦑
定义和初始化：
struct P
{
int a;
int b;
}p;
struct P p1;//定义结构体变量p2
struct P p2 = { 1,2 };//初始化：定义变量的同时赋初值。
struct Stu //类型声明
{
char name[15];//名字
int age; //年龄
};
struct Stu s = { "zhangsan", 20 };//初始化
struct P
{
int a;
int b;
}p;//声明类型的同时定义变量p
还有结构体嵌套的情况。
struct book
{
char name[20];
int num;
char id[20];
}b1 = {"C语言",20,"1234"};
struct Node
{
struct book b;
struct Node* next; //结构体嵌套
};
int main()
{
printf("%s %d %s\n", b1.name, b1.num, b1.id);
struct Node n = { {"Java", 20, "321"}, NULL };//结构体嵌套初始化
return 0;
}
结构体内存对齐
我们已经掌握了结构体的基本使用了。 现在我们深入讨论一个问题：计算结构体的大小。
这也是一个特别热门的考点： 结构体内存对齐
我们来看这两个结构体
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S1));//12
printf("%d\n", sizeof(struct S2));//8
return 0;
为什么大小不一样呢？
这就要讲到结构体内存对齐
首先得掌握结构体的对齐规则
- 第一个成员在与结构体变量偏移量为0的地址处。
- 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。
对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。
VS中默认的值为8 - 结构体总大小为最大对齐数（每个成员变量都有一个对齐数）的整数倍。
- 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍
我们来看
这样一来S2也就很好解释了，
struct S2
{
char c1;
char c2;
int i;
};
c1 0
c2 1
i 4-7
总大小刚好是8。
一般的我们已经知道了，现在来看看嵌套的
struct S3
{
double d;
char c;
int i;
};
printf("%d\n", sizeof(struct S3));
struct S4
{
char c1;
struct S3 s3;
double d;
};
printf("%d\n", sizeof(struct S4));
struct S3的大小是16
那么S4的大小是多少呢？
首先看到最后一个原则，也就是S3在S4内对齐时大小为8，是最大对齐数。
一共就是32。
补充一句VS和Linus的
为什么存在内存对齐?
大部分的参考资料都这样说的：
1.平台原因(移植原因)：
不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特 定类型的数据，否则抛出硬件异常 。（比如只能访问4的倍数的地址上的数据）
抛出硬件异常是指在计算机系统中，发生了与硬件相关的错误或异常情况。这些异常可能由于硬件故障、硬件错误、硬件不兼容性或硬件操作不当等原因引起。
2. 性能原因：
数据结构(尤其是栈)应该尽可能地在自然边界上对齐。
原因在于，为了访问未对齐的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。（32位下一次访问4个byte）
不考虑对齐要读取两次才能读完i的4个字节的内容（32位）.
而考虑的话，i只需要读取一次就能读完，
这里实际上就提高了效率，牺牲空间来提升效率。
要读取一次就能读完，
这里实际上就提高了效率，牺牲空间来提升效率。
总体来说： 结构体的内存对齐是拿空间来换取时间的做法。
那在设计结构体的时候，我们既要满足对齐，又要节省空间，如何做到：
其实很简单：
//例如：
struct S1
{
char c1;
int i;
char c2;
};
struct S2
{
char c1;
char c2;
int i;
};
都是同样的结构体成员，但是把小的放在一起就节省空间 (这是上面讲过的)。
修改默认对齐数🐣
struct S
{
char c;//1
double d;//8
};
int main()
{
struct S s;
printf("%d\n", sizeof(s));
return 0;
}
还是这样这个代码
大小为16。
但是呢，我们可以用用#pragma pack() 来修改默认对齐数
#pragma pack(4)
struct S
{
char c;//1
double d;//8
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
struct S s;
printf("%d\n", sizeof(s));
return 0;
}
我们将默认对齐数修改到4时，大小就已经变化了，
为什么呢？char c; 0
double d; 4：8 = 4， 4-11。 一共就是12。
也可以设置不内存对齐，紧挨着排#pragma pack(1)
#pragma pack(1)
struct S
{
char c;//1
double d;//8
};
#pragma pack()//取消设置的默认对齐数，还原为默认
int main()
{
struct S s;
printf("%d\n", sizeof(s));
return 0;
}
结论： 结构在对齐方式不合适的时候，我么可以自己更改默认对齐数。
虽然我们能够随便改变，但是我们要改最好还是让默认对齐数是2的幂，也是为了让我们的硬件有一个好的发挥
offsetof及其实现💥
其实offsetof是用宏来实现的，与一般的函数不同。
这个宏是用来查看结构体成员的偏移量的，并返回偏移量值。
我们知道结构体的首元素需要放在0偏移处。之后的成员要放在正确的偏移处。
struct S3
{
double d;
char c;
int i;
};
int main()
{
printf("%d\n", sizeof(struct S3));
printf("%u\n", offsetof(struct S3, d));
printf("%u\n", offsetof(struct S3, c));
printf("%u\n", offsetof(struct S3, i));
return 0;
}
来看看这个
我们可以算一算确实是这样，
double d; 0 - 7
char c; 8
int i; 12-15
一共16。
每个变量最开始的地方就是这个变量相对于0的偏移量。
那么既然这是一个宏那该如何去实现呢？
我们需要借助这幅图好好理解一下，到底偏移量意味着什么。
我们看到实际上偏移量就是该变量的地址的值减去首地址。
假设0偏移处地址是0x0012ff40。
0x0012ff48-0x0012ff40=8。
0x12ff4c-0x0012ff40 = 12。
这样我们对偏移量就有了不一样的理解。
那么我们如何来实现呢？
#include<stddef.h>
#define OFFSETOF(struct_type,member) (int)&(((struct_type *)0)->member)
struct S3
{
double d;
char c;
int i;
};
int main()
{ printf("%u\n", offsetof(struct S3, d));
printf("%u\n", offsetof(struct S3, c));
printf("%u\n", offsetof(struct S3, i));
printf("%u\n", OFFSETOF(struct S3, d));
printf("%u\n", OFFSETOF(struct S3, c));
printf("%u\n", OFFSETOF(struct S3, i));
return 0;
}
我们就是用这一行代码来实现的。
(int)&(((struct_type *)0)->member)
- (struct_type
*)0：将0强制转换为指向struct_type类型的指针。这里假设结构体的实例位于0地址处，实际上并不是真的将结构体放在0地址处，而是为了方便计算偏移量而做的假设。 - ((struct_type*)0)->member：通过上述转换得到的指针，访问结构体中的成员member。这里并不会真的访问到实际的结构体，而是为了计算成员的偏移量而进行的操作。
3. (int)&(((struct_type*)0)->member)：通过取地址操作&，将上述成员的假设地址转换为实际的地址，并将其强制转换为int类型。这样就得到了成员的偏移量。
总结😈
这篇博客是用来梳理结构体知识的，并不算太难，算的上是对知识的检查和回顾，结构体对数据结构的学习十分重要希望大家都能学会 完(๑′ᴗ‵๑)
