【C语言】自定义类型：结构体深入解析（二）结构体内存对齐&&宏offsetof计算偏移量&&结构体传参

文章目录

• 📝前言
• 🌠 结构体内存对齐
• 🌉内存对齐包含结构体的计算
• 🌠宏offsetof计算偏移量
• 🌉为什么存在内存对⻬?
• 🌠 结构体传参
• 🚩总结

📝前言

本小节，我们学习结构的内存对齐，理解其对齐规则，内存对齐包含结构体的计算，使用宏

offsetof

计算偏移量，为什么要存在内存对齐？最后了解结构体的传参文章干货满满！学习起来吧😃！

🌠 结构体内存对齐

结构体内存对齐指的是结构体中各成员变量在内存中的存储位置按照一定规则对齐。
既然是按照一定规则，那得首先了解它的对齐规则：

1. 结构体的第一个成员对齐到和结构体起始位置偏移量为0的地址处。
2. 其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。对齐数 = 编译器默认的一个对齐数 与 该成员变量大小的较小值。

• VS 中默认的值为 8
• linux 中gcc没有默认对齐数，对齐数就是成员自身的大小

1. 结构体总大小为最大对齐数（结构体中的每一个成员都有一个对齐数，所有对齐数中的）的整数倍。
2. 如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍。

• 来代码理解：

structS1{char c1;char c2;int i;};structS2{char c1;int i;char c2;};intmain(){printf("%d\n",sizeof(structS1));printf("%d\n",sizeof(structS2));return0;}

代码运行：

分析：

首先结构体

S1

的成员有三个，根据对齐规则：结构体的第一个成员对齐到结构体变量起始位置偏移量为

0

的地址处-—>

C1

放在偏移量为

0

的地址处，接下来第二个

C2

就从第

2

个规则按对齐数进行放置，

C2

的字节数

char

类型，大小为

1

，VS的默认对齐数为8，对齐数取的是默认对齐数和成员变量字节大小的较小值，

1<8

，取

1

为对齐数，然后偏移量为

1

的位置放

1

，此时再看第三个变量i的字节大小为

4

，

4<8

，对齐数为4，当放在偏移量为2时，2不是4的整数倍，跳过，

3

也不是，跳过，而当偏移量为4时刚好是4的整数

1

倍（

4*1=4

），然后占据为

4

个字节空间，从偏移量

0

到最后偏移量的空间就是结构体的总大小，为

8

，此时还没有结束，要验证，根据第三条规则结构体的总大小为最大对齐数的整数倍，最大对齐数为

4

（

4>1>1

），而结构刚才计算出来是

8

刚好是

4

整数倍（

4*2

）当这些都符合了，结构体的大小就是

8

了。

一个例子你可能想是不是碰巧，那么第二个例子：
结构体

S2

中有三个成员，

C1

大小为一，第一个成员放在偏移量为

0

处，第二个成员

i

大小为

4

，偏移量

1

，

2

，

3

都不是

4

的整数倍，然后这些空间都跳过不放数据，（注：他开辟了空间，但他此时不用，你可能会想：这不浪费吗？文章我们慢慢解释）然后偏移量为

4

时为整数倍，从偏移量

4

开始放

i

直到

7

，第三个元素

C2

大小为

1

，

1

的整数倍任何数的整数倍，可以直接放，当放在偏移量

8

处时，全部成员都放完了，我们还要对他进行验证是否为整数倍。

S2

最大对齐数是

4

，偏移量

9

,

10

都不对，当偏移量为

11

，从

0

到

11

刚好为

12

，为

4

的倍数（

4*3=12

）。所以

S2

总大小为

12

！

🌉内存对齐包含结构体的计算

structS3{double d;char c;int i;};intmain(){printf("%zd\n",sizeof(structS3));return0;}

运行结果：16

分析：

首先第一个成员为

d

，放在偏移量为

0

处，

double

类型，大小为

8

，位置范围为

0 ~ 7

，第二个成员

C

,类型为

char

，大小为

1

，

1<8

，对齐数为

1

,

1

可以直接放，占据

8

位置处，第三个成员

i

，大小为

4

,

4<8

，对齐数是

4

,偏移量

9

,

10

,

11

都不是

4

的倍数，

12

开始占据

4

个空间到

15

，范围

0 ~ 15

总大小为

16。

S3结构体是三个成员（

8>4>1

）大小最大是

double

大小为

8

，此时总结构体大小

16

刚好为

8

的

2

倍，符合条件。

• [] 包含S3的结构体

structS4{char c1;structS3 s3;double d;};intmain(){printf("%zd\n",sizeof(structS4));return0;}

运行结果：32

第一个成员

C1

对应到偏移量为

0

处，大小为

1

，

s3

为结构体，s3的大小为16，根据第四条规则【如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整数倍。】，也就是说结构体s3最大对齐数为double的8，用8对齐到S4中整数倍，1,2,3,4,5,6,7都不是8的整数倍，跳过，当偏移量为8时为对齐数8的整数倍时，然后结构体整体大小为16，占据范围为8 ~ 23，接下来就是第三个元素

d

，大小为

8

，偏移量

24

就是

8

的整数倍，占据了

24 ~ 31

,所有成员都完成了，偏移量范围在

0 ~ 31

，总大小就是

32

。答案就是

32

.看到这里的你，给自己鼓个掌，继续加油。

🌠宏offsetof计算偏移量

宏offsetof可以用来计算结构体成员相对于结构体起始位置的偏移量。
宏offsetof原型：

offsetof(type, member)
type是结构体类型
member是结构体中的成员。

注意：使用

offsetof

宏计算结构体成员偏移量时，需要包含

stddef.h

头文件

#define_CRT_SECURE_NO_WARNINGS1#include<stdio.h>#include<string.h>#include<stddef.h>structS1{char c1;char c2;int i;};structS2{char c1;int i;char c2;};structS3{double d;char c;int i;};structS4{char c1;structS3 s3;double d;};intmain(){structS1 s1 ={0};//8structS2 s2 ={0};//12printf("结构体大小：\n");printf("S1=%zd\n",sizeof(structS1));//8printf("S2=%zd\n",sizeof(structS2));//12printf("S3=%zd\n",sizeof(structS3));//16printf("S4=%zd\n",sizeof(structS4));//32printf("\n");printf("结构体S1成员的偏移量：\n");printf("c1=%zd\n",offsetof(structS1, c1));//0printf("c2=%zd\n",offsetof(structS1, c2));//1printf(" i=%zd\n",offsetof(structS1, i));//8printf("\n");printf("结构体S2成员的偏移量：\n");printf("c1=%zd\n",offsetof(structS2, c1));//0printf(" i=%zd\n",offsetof(structS2, i));//4printf("c2=%zd\n",offsetof(structS2, c2));//8printf("\n");printf("结构体S4成员的偏移量：\n");printf("c1=%zd\n",offsetof(structS4, c1));//0printf("s3=%zd\n",offsetof(structS4, s3));//8printf("d=%zd\n",offsetof(structS4, d));//24return0;}

运行+图对比：

🌉为什么存在内存对⻬?

1. 平台原因 (移植原因)： 不是所有的硬件平台都能访问任意地址上的任意数据的；某些硬件平台只能在某些地址处取某些特定类型的数据，否则抛出硬件异常。
2. 性能原因： 数据结构(尤其是栈)应该尽可能地在⾃然边界上对⻬。原因在于，为了访问未对⻬的内存，处理器需要作两次内存访问；⽽对⻬的内存访问仅需要⼀次访问。

假设⼀个处理器总是从内存中取

8

个字节，则地址必须是

8

的倍数。如果数据没有对齐，CPU需要额外的时间来处理非对齐的内存访问，这会降低性能。

总结一句话来说：
结构体的内存对⻬是拿空间来换取时间的做法。

在设计结构体时，既要满足内存对齐要求，又要考虑节省空间，可以采取以下方法：

• 尽量将较小类型如char、short等成员放在结构体开始位置。这可以减少由对齐产生的内存浪费。 例如前面的S1和S2就很典型：

structS1{char c1;int i;char c2;};structS2{char c1;char c2;int i;};

阿森把宝图解：

• 修改默认对⻬数#pragma 这个预处理指令，可以改变编译器的默认对⻬数。#pragma 原型：

#pragmapack(push,1)// 将结构体对齐数设置为1字节 structS1{char a;int b;};#pragmapack(pop)// 恢复之前的对齐数

• pack(push, 1)表示将当前对齐数压入栈，并设置新的对齐数为1字节
• pack(pop)表示从栈中弹出之前的对齐数，恢复默认对齐数

可以直接指定对齐数：

#pragmapack(1)structS1{// 成员对齐数为1字节char a;int b;};#pragmapack()// 恢复默认对齐数

例子：

#pragmapack(1)structS1{char c1;char c2;int i;};#pragmapack()intmain(){printf("%d\n",sizeof(structS1));return0;}

输出：

图解对比：

🌠 结构体传参

1. 按值传递（传结构体） 函数形参声明为结构体，实参传递结构体变量。此时在函数内对形参的修改不会影响实参。

structSt{int x;};voidfunc(structSt st){
    st.x =10;}intmain(){structSt s ={0};func(s);//传结构体printf("%d\n", s.x);}

输出：

1. 按地址传递 函数形参定义为结构体指针，实参传递结构体变量的地址。函数内对形参所指结构体的修改会影响实参。

structSt{int x;};voidfunc(structSt* p){
    p->x =10;}intmain(){structSt s ={0};func(&s);printf("%d\n", s.x);}

输出：

1. 传结构体指针 实参直接传结构体指针：

structSt{int x;};voidfunc(structSt* st){
    st->x =10;}intmain(){structSt s;structSt* p =&s;func(p);printf("%d\n", s.x);}

输出：10

分析：
传值也就是把整个结构体传过去，我们知道形参是是实参的一份临时拷贝，需要再创建特别大的空间来存储结构体。

无论是传结构体指针还是传结构体地址，本质上都是传地址，但是传地址，只需要创建一个小的空间来存储地址。

选择传地址比较好一些。
原因：
函数传参的时候，参数是需要压栈，会有时间和空间上的系统开销。
如果传递⼀个结构体对象的时候，结构体过⼤，参数压栈的的系统开销⽐较⼤，所以会导致性能的下降。
总结：
结构体传参的时候，要传结构体的地址。

🚩总结

这次阿森和你一起学习结构体的 结构体内存对齐，内存对齐包含结构体的计算，使用宏

offsetof

计算偏移量，为什么存在内存对⻬? 结构体传参的本质，阿森将下一节和你一起学习结构体实现位段。

感谢你的收看，如果文章有错误，可以指出，我不胜感激，让我们一起学习交流，如果文章可以给你一个小小帮助，可以给博主点一个小小的赞😘