一、前言

在结构体章节，我们掌握了结构体的基本使用，但是现在我要你去计算一个结构体的大小，你会怎么做呢？

现在我定义了两个结构体，通过观察可以发现它们内部的成员变量都是一样的，均有c1、c2、i三个成员变量，那此时分别去计算它们两个结构体的大小，最后的结果会是多少呢？会是一样的吗

c 复制代码

struct S1 {
	char c1;
	int i;
	char c2;
};

struct S2 {
	char c1;
	char c2;
	int i;
};

int main(void)
{
	printf("%d\n", sizeof(struct S1));
	printf("%d\n", sizeof(struct S2));
	return 0;
}

通过运行可以发现两者是不一样的，这是为什么呢？如果你没有结构体内存对齐的相关知识，那相信你一定会这么去计算：
- 在结构体S1中，c1的类型为【char】，是1个字节；
- i的类型是【int】，是4个字节
- c2的类型为【char】，是1个字节；
那么最后的结果就是1 + 4 + 1 = 6B，可事实呢，原不止这些。。。

结构体偏移量计算：offsetof

就上面这么来看还是看不出什么细节的内容，给读者介绍一个宏叫做offsetof，它可以==用来计算结构体成员相对于起始位置的偏移量==

它的第一个参数是结构体类型，第二个参数是结构体成员

c 复制代码

printf("%d\n", offsetof(struct S1, c1));
printf("%d\n", offsetof(struct S1, i));
printf("%d\n", offsetof(struct S1, c2));

最后，计算出来的结果分别是【0】【4】【8】，那我们可以通过画内存图来看看结构体中的三个成员变量在内存中究竟是如何分布的
可以看出，因为总的结构体大小为12B，可是在放完这3个成员后中间空出了三个位置 ，并且对于最后在c放完之后还没有到达12B，所以还得再浪费3个空间的废位置

为什么会出现上面这样的现象呢？对于结构体内存对齐的规则是怎样，让我们继续看下去👇

二、规则介绍

第一个成员在与结构体变量偏移量为0的地址处
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处 ==对齐数 = 编译器默认的一个对齐数与该成员大小的较小值 ==
- 【VS 中默认的值为8、Linux环境默认不设对齐数（对齐数是结构体成员自身的大小）】
结构体总大小为最大对齐数 （每个成员变量都有一个对齐数）的整数倍
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

例题的分解与细说

知晓了上面这些规则后，我们再来回顾一下上面这个结构体的大小该如何计算

假设我这里创建一个结构体变量叫做ss，它的起始地址就从0开始，所以根据第一条规则，第一个成员变量在与结构体变量偏移量为0的地址处 ，而且它的类型还是char，所以只占1个内存单元

接下去看第二个成员变量i，其为整型所以在内存中就需要存储4个字节的大小，此时便要拿其和VS下默认对齐数8去进行比较，取较小的值4
算出来【4】之后便要对齐到4整数倍的地址处，那就是4这块空间，往下一直占用4个字节，这就是成员变量i在这个结构体中的内存占用分布
那既然这个i是从4的位置开始放的，中间空出来的位置就不会再放置其他成员变量了，那么这个3个空间也就浪费了

接下去放置第三个成员变量c2，char类型的变量为1个字节，和8比较取小就是1，那就要将其放到1整数倍的地址处，那其实任何空间都是可以的，直接放到这个【8】的位置就行
那截止目前为止这个结构体中的所有成员变量都放置完了，此时去计算一个所占的内存空间就可以发现只有9个字节。但是在一开始我们计算的这个结构体的大小为12个字节，可是现在还差3个字节，所以最后就要去进行一个填充。但是，为什么呢？

这就要用到第三条规则了：==结构体总大小为最大对齐数的整数倍==
那在这么计算下来之后，就可以知道结构体中的最大对齐数为4，那么【9】、【10】、【11】都不是它的整数倍，只有【12】是它的整数倍的地址处（注意这里是地址处！），因此我们需要填充3个字节，此时从0 ~ 11就有12个字节了，便为4的整数倍 👉这就是【12】如何被计算出来的全过程，你听懂了吗？

看完了，这个结构体后，还记得结构体S2吗，我再来讲一道，当然你也可以试着自己写写画画看👈

首先还是一样，c1放在这个与结构体变量偏移量为0的地址处，而且它的类型还是char，所以只占1个内存单元
接下去还是一样，在放置第二个成员变量开始就要考虑【对齐数】了，char所占的字节为1B，与8去进行比较一下就可以知道1来得小，那我们直接放在偏移处为1的地方就可以了，此时在内存中也只占了1个字节

接下去放置第三个成员变量【i】，大小为4个字节小于8因此选择在4的整数倍的地址处开始放置这个变量，整型占4个字节，所以一直占用到偏移量为7的地方
接下去就是计算整个结构体的大小，最大对齐数 为4，所以要为4的整数倍，此时去计算一下得知从0 ~ 7偏移了7个字节，占用了8个空间，刚好为4的整数倍，所以结构体S2的大小为【8】是这么算出来的，你明白了吗？

三、习题演练

通过上面两道例题的讲解，相信你对如何去计算结构体大小一定有了一个自己的认识，接下去就让我们趁热打铁🔥来做两道题目再练一练，看看自己是否真的掌握了

1、练习①

你可以先试着自己做一做，然后和我对一下是否正确

c 复制代码

struct S3
{
	double d;
	char c;
	int i;
};
printf("%d\n", sizeof(struct S3));

【分析】：

首先看到第一个成员变量，从偏移量为0的地址处开始放起，因为double类型的数据在内存中占8个字节，所以一直占用偏移处为7的地方

对于第二个成员变量【c】，类型为char，所以在内存中占用1个字节，那直接放在偏移量为8的地址处即可
接下去来安排第三个成员变量【i】，整型占用4个字节，比VS下默认对齐数8来得小所以【对齐数为4】，去寻找4整数倍的地址处，【9】、【10】、【11】都不是，【12】是4的整数所偏移的地址处，从此处开始往下数4个字节的空间，刚好放满15
最后我们便去计算整个结构体的大小，为最大对齐数的整数倍，最大对齐数是8，计算一下放置三个成员变量占了16个空间，刚好是8的整数倍，因此16即为结构体的大小

运行结果如下：

也可以通过【offsetof】来验证一下

2、练习②

接下去再来做一道练习，涉及结构体嵌套的问题，对应的需要使用到规则4，忘记了可以翻上去看看👈

c 复制代码

struct S3
{
	double d;
	char c;
	int i;
};

struct S4
{
	char c1;
	struct S3 s3;	//成员变量为另一个结构体
	double d;
};

因为本题的结构体比较大，所以就标出4的整数倍所在的地址

首先还是一样，来看到第一个成员变量【c1】，放到与结构体变量偏移量为0的地址处 ，又因为类型为char，所以只占一个字节的空间

接下去，就是嵌套的结构体s3，此时我们要对齐到s3这个结构体中最大对齐数的整数倍处 ，那么最大对齐数就是【8】，所以要从8的地址处开始往下放置，那要占用多少空间呢？这就是s3这个结构体的大小【16】，所以一直往下数16个空间即可，一直到23这个地址处
那么中间的这7个位置就算是浪费了👈

最后就是这个【d】，与VS中的默认对齐数一致，所以为【8】，下一个24刚好为8整数倍的地址处，所以从这开始放，double类型的数据在内存中占8个字节，所以一直到31的地址处
然后来算整个结构体s4的大小，为所有最大对齐数（含嵌套结构体的对齐数）的整数倍，也就是取s3和s4中的最大对齐数，那也就是【8】，计算一下结构体s4所占的内存空间为32，刚好为8的整数倍，所以整个结构体的大小即为32

运行结果如下：

可以通过【offsetof】再来验证一下

四、为什么存在内存对齐?

经过了两道例题和两道练习题的训练，相信你对如何计算结构体的大小一定是心中有数了，但在阅读的过程中你是否有疑惑为什么会存在这个【结构体内存对齐】呢？有什么实际意义吗？

1、平台原因(移植原因)

不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常

2、性能原因

假设下面有一个结构体，内部有两个成员变量c和i，然后要在内存中存储它们，我分为了两种，一个是【无内存对齐】，呈现的是紧密存放；一个是【内存对齐】，需要考虑到最大对齐数
然后在32位平台下去分别访问结构体中的成员，假设现在读取数据的时候一次性读四个字节。
- 首先看到的是【无内存对齐 】的结构体内存分布，读一次就能读到c，但是若要全部读取完i，就还需要再读取一次，那访问到所有的成员变量就需要两次；
- 接下去看到的是【内存对齐 】的结构体内存分布，因为内存对齐的缘故，所有两个成员变量c和i互不干扰，此时再看到成员变量i，从它的初始地址处开始读取，一次读4个字节，那么读1次就刚刚好可以读完这个变量了，而不是像上面那样还需要再读一次

所以原因就在于，为了访问未对齐 的内存，处理器需要作两次内存访问；而对齐的内存访问仅需要一次访问。

总体来说：

结构体的内存对齐是拿==空间来换取时间==的做法

了解了为什么会存在内存对齐之后，我们再回到一开始的这两个结构体，你是否有想过为什么两个结构体的成员变量都一模一样但是大小却是一个【12】，一个【8】呢？

没错，就是你想到的它们所存放的位置不一样罢了。因为要存在内存对齐，所以若两个对齐数大的成员变量定义在一起的话为了满足规则就可能会浪费很多空间的内存。
但若是两个对齐数较小甚至相同规定的变量定义在一块的话，可能它们就是挨着放的，占用的空间少了↓，那最后结构体的大小就变小了

c 复制代码

struct S1 {
	char c1;
	int i;
	char c2;
};

struct S2 {
	char c1;
	char c2;
	int i;
};

所以，那在设计结构体的时候，我们既要满足对齐，又要节省空间，就要让占用空间小的成员尽量集中在一起

五、如何修改默认对齐数

之前我们见过了 #pragma 这个预处理指令#pragma comment，用来链接函数的静态库。这里我们再次使用，可以改变我们的默认对齐数

用法很简单#pragma pack(1)就可以设置默认对齐数为1，#pragma pack()就可以取消设置的默认对齐数，还原为默认。到它为止的默认对齐数还是被修改后的对齐数
接下去就来看下面这个修改完默认对齐数后的结构体，它的大小会是多少呢？

c 复制代码

#pragma pack(1)//设置默认对齐数为1
struct S1
{
	char c1;
	int i;
	char c2;
};
#pragma pack()//取消设置的默认对齐数，还原为默认

int main()
{
	//输出的结果是什么？
	printf("%d\n", sizeof(struct S1));
	
	return 0;
}

可以看到，若是默认的对齐数设置为1的话，那其实可以看出每个成员变量的对齐数就都是1了，那么也就不存在浪费的现象，因为任何数都是1的整数倍，所以3个成员变量的内存分布如下，大小即为【6】

运行结果如下：

可以通过【offsetof】再来验证一下

结论：

结构在对齐方式不合适的时候，我么可以自己更改默认对齐数

六、实战演练

✍一道百度笔试题： offsetof 宏的实现

在上面的每一个结构体计算后，我都使用到了offsetof这个宏，和我画出来的内存分布图完全就是一致的，那它的原理到底是怎样的呢？马上来探究一下:mag:

曾经有一年的百度笔试题就考到了有关offsetof 的实现原理

👉 ==【原题】：写一个宏，计算结构体中某变量相对于首地址的偏移，并给出说明==

那要如何去实现呢？如果对宏不是很了解的读者可以看看详解程序环境和预处理
我们通过上面的结构体S1进行讲解。列出3个成员变量放置的初始地址，其实【offsetof】计算的也就是每个变量在内存中的起始地址相较于首地址偏移了多少 ，那将它们进行一个相减就可以得出0、4、8这三个结果

但是上面的这些地址太复杂了，都是十六进制的，接下去我们来将c1这块地址设置为0，那么
- 【c1】相对于自己的偏移量就是&c1 - 0
- 【i】相对于自己的偏移量就是&i - 0
- 【c2】相对于自己的偏移量就是&c2 - 0
但其实这可以看出，虽然每个成员变量各自的偏移量为他们的地址减去首地址，但是可以看出这减了和没减有什么区别呢？所以可以得出它们三者的偏移量其实就是他们各自的初始地址

知道了上面这些我们就可以使用【宏】来实现每个成员变量偏移量的计算了

c 复制代码

#define OFFSETOF(m_type, m_name)	(int)&(((m_type *)0)->m_name)

不过相信你一定看不懂上面这个宏，所以我会来一步步讲解一下

m_type是结构体变量；m_name是结构体成员

首先是地址为0的这个地方要放置结构体成员，但是0是一个整型，所以我们使用强制类型转换将0转换成一个结构体的指针，那么在外部传入结构体成员变量的时候就符合类型了

c 复制代码

#define OFFSETOF(m_type, m_name)	(m_type *)0

printf("%d\n", OFFSETOF(struct S1, c1));

那既然这是一个结构体指针的话，就可以访问到其内部的结构体成员变量，也就是这个m_name

c 复制代码

#define OFFSETOF(m_type, m_name)	((m_type *)0)->m_name

那么在上面说到过，每个结构体成员变量的地址就是它相对于起始位置的偏移量

c 复制代码

#define OFFSETOF(m_type, m_name)	&(((m_type *)0)->m_name)

但是呢，在打印的时候可以看出对于偏移量而言都是第一个整数，所以还要对取到的地址偏移转换为整型，便是最后的结果

c 复制代码

#define OFFSETOF(m_type, m_name)	(int)&(((m_type *)0)->m_name)

下面是流程图：

下面是运行结果：

💬两道高频面试题

结构体怎么对齐？为什么要进行内存对齐？

结构体内存对齐存在对应的规则，规则如下
1. 第一个成员在与结构体变量偏移量为0的地址处
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处 ==对齐数 = 编译器默认的一个对齐数与该成员大小的较小值 ==
  - 【VS 中默认的值为8、Linux环境默认不设对齐数（对齐数是结构体成员自身的大小）】
3. 结构体总大小为最大对齐数 （每个成员变量都有一个对齐数）的整数倍
4. 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍
为什么要进行内存对齐呢？原因有两个，一个是平台本身的原因，任意地址上的任意数据是不能随意访问的，如果不正确访问可能会造成硬件异常。第二个就是性能原因，为了访问未对齐的内存，处理器需要作两次内存访问 ；而对齐的内存访问仅需要一次访问

如何让结构体按照指定的对齐参数进行对齐？能否按照3、4、5即任意字节对齐？

可以的，只需要使用一个预处理指令#pragma pack(3)便可以将默认对齐数修改为3，其他的也是同理，因为结构体默认对齐数发生了变化，此时就会导致结构体大小发生变化

七、总结与提炼

最后来总结一下本文所学习的内容:book:

在本文中，主要是介绍了如何去计算一个结构体的大小，最重要、最核心的还是开头的4条规则，我们再来回顾一下

第一个成员在与结构体变量偏移量为0的地址处
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处 ==对齐数 = 编译器默认的一个对齐数与该成员大小的较小值 ==
- 【VS 中默认的值为8、Linux环境默认不设对齐数（对齐数是结构体成员自身的大小）】
结构体总大小为最大对齐数 （每个成员变量都有一个对齐数）的整数倍
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

有了规则之后，将它们灵活地运用到实际的题目中，只要掌握了方法，就感觉其实计算结构体的大小也没有那么复杂，就是对于【嵌套结构体】的规则有些复杂，要考虑到另一个结构体中的最大对齐数
接下去，我们就谈到了为什么在计算这些结构体的时候会存在内存对齐的现象，对于了设置与不设置内存对齐便观察到这是【空间换时间】的做法
谈了很久的offsetof()，但是不清楚原理是什么👉这不，百度笔试题就考到了，于是我们就去自己通过一个宏实现了一下这个偏移量的求解，虽然过程很复杂，但是在我一步步的细讲下，相信聪明的你一定有所理解😁在理解了结构体内存对齐的各方面之后，面对两道面试题也是毫不畏惧💪

可以发现仅仅是非常小的一个知识点，我却讲解了近万字，因为这是校招的笔试面试中C语言这一块的热门考点，如果有投递相关岗位的同学一定要搞清楚每一步🥰

C生万物 | 校招热门考点 —— 结构体内存对齐

一、前言

结构体偏移量计算：offsetof

二、规则介绍

例题的分解与细说

三、习题演练

1、练习①

2、练习②

四、为什么存在内存对齐?

1、平台原因(移植原因)

2、性能原因

五、如何修改默认对齐数

六、实战演练

✍一道百度笔试题： offsetof 宏的实现

💬两道高频面试题

七、总结与提炼