@TOC

一、结构体的声明

1、结构的基础知识

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量

2、结构的声明

下面是结构体声明的形式

struct tag
{
	member-list;
}variable-list;

例如现在要使用结构体来描述一个学生：里面就存放了一个学生所具有的基本信息，如姓名、年龄、性别、身高

struct Stu {
	char name[20];	//姓名
	int age;		//年龄
	char sex[2];	//性别
	float height;	//身高
};	

或者用结构体来描述一本书，里面存放了：书名、作者、定价、书号

struct Book {
	char name[20];
	char author[20];
	double price;
	int id;
};

==不仅如此，结构的成员还可以是标量、数组、指针，甚至是其他结构体==

3、特殊的声明

接下去我来介绍一种特殊的结构体声明形式，也就是【匿名结构体】，什么是匿名结构体呢？也就是没有结构体名称

//匿名结构体类型
struct
{
	int a;
	char b;
	float c;
}x;
struct
{
	int a;
	char b;
	float c;
}a[20], * p;

• 可以看到，我故意将两个结构体的内容设置成一样，然后直接在声明的时候就定义出了它们各自的结构体成员，第二个结构体定义了一个结构体数组和结构体指针
• 此处我使用这个结构体指针去接收第一个结构体定义出来的变量x，此时你应该会觉得合情合理，但是编译之后却看到【它们的类型不兼容】，这是为什么呢？

p = &x;

原因其实就在于这个【匿名结构体】

• [x] 对于匿名结构体来说呢只能在声明的时候用一次，后面就不能再用了。所以这个东西其实也没什么用，了解一下就行
• [x] 不过这个语法形式和C++中的【匿名对象】很类似，声明周期只在当前行，进入下一行就会调用析构函数

4、结构的自引用

有关结构体自引用这块，就要说到数据结构里面的相关知识了，可能有的读者没听过，这也没关系，准备发车🚗

• 说起自引用这一块最典型的其实就是数据结构中的《链表》，可能有的C语言教科书上也会提及。但如果要说链表的话那就得先说说顺序表
  • 对于顺序表而言，就是存放在内存中一块连续的存储空间，具体可以看看 数据结构体之循序表
  • 对于链表而言，是由存放在内存中一些不连续结点所链接而成的，，具体可以看看 数据结构体之链表
    
• 那要如何去声明一个链表的结构体，下面这样可行吗？

struct Node
{
	int data;
	struct Node next;
};

• 可以看到，程序报出了错误，说是【struct Node未定义】，这是为什么呢？

• 其实对于链表的单个结点来说，是由两个域组成的，一个叫做【数据域】，是存放结点数据的，一个叫做【指针域】，是存放下一个结点在堆内存中地址，图示如下：
  • 这里讲的不是很清楚，了解一下即可，有兴趣的同学可以去看看上面那篇链表的文章

• 那指针域要存放一个结点，也就是结构体的地址，就必须要一个结构体指针，此时我们就可以将代码写成下面这样，每个结构体指针都指向下一个结点的地址

struct Node
{
	int data;
	struct Node* next;
};

• 此时就可以通过这个结构体定义出有关链表的结点，然后去初始化链接每个结点即可

struct Node list;

但你是否有觉得上面这种形式太麻烦了，每次在定义一个结构体变量的时候都要在前面加上一个struct，如果可以不加该多好

• 这个其实很好办，只需要在结构体声明的时候在前面加上要一个typedef关键字即可，然后再定义变量的位置为其重命名一下，那在定义结构体变量的时候就不需要再加上struct关键字了

typedef struct Node
{
	int data;
	struct Node* next;
}Node;

Node list;

【友情提示】：可不能把结构体定义成下面这样，Node* next;这种写法是错误的，因为到这行为止，结构体还不认识Node，所以是不可以使用它的

typedef struct Node
{
	int data;
	Node* next;
}Node;

二、结构体变量的定义和初始化

有了结构体类型，那如何定义变量，其实很简单。

• 第一种方法就是直接在声明出结构体的时候就可以定义结构体变量，例如这里的s1、s2、s3指的的都是一个学生，而且它们属于全局变量

struct Stu {
	char name[20];	//姓名
	int age;		//年龄
	char sex[2];	//性别
	float height;	//身高
}s1, s2, s3;	//全局变量

• 第二种方法就是脱离结构体进行定义，不过这和我们在定义普通变量的格式是一样的，也要在前面加上数据类型，比如int a前面的int
• 像 struct Stu就是这个结构体的类型，不要忘记加上前面的struct这个修饰符了。下面的【ss】定义在外面，那就是全局变量；【su】定义在函数内部，那就是局部变量

struct Stu ss;		//全局变量
int main(void)
{
	struct Stu su;	//局部变量
	return 0;
}

• 如果你觉得每次写 struct Stu太麻烦了，也是有办法了，那就是为其进行一个重命名，一般我们直接在结构体最前面加上一个typedef关键字，然后在定义处为其做一个重命名

typedef struct Stu {
	char name[20];	//姓名
	int age;		//年龄
	char sex[2];	//性别
	float height;	//身高
}S;		

因此可以说 S == struct Stu，定义方式就简洁了许多

struct Stu su;
S su2;

接下去来讲讲结构体如何初始化

• 我们将初始化的内容使用花括号{ }括起来，里面就可以对结构体的成员进行一个初始化，分别意义对照进行初始化即可

struct Stu su = { "zhangsan", 20, "男", 180 };

• 这里我又定义了一个【点】的结构体，成员变量即为坐标x和坐标y

struct Point {
	int x;
	int y;
};

• 对其初始化也很简单，如下

struct Point p = { 10, 20 };

但是现在我又有了一个结构体，这个结构体内部呢又有一个结构体，就是上面这个【点】，这该如何初始化呢？

struct MyStruct
{
	char c;
	struct Point p;
	double d;
	char str[20];
};

• 很简单，其他普通的成员变量就正常初始化，结构体成员变量的话也按照结构体的方式使用花括号括起来即可

struct MyStruct ms = { 'c', {40, 80}, 3.14f, "haha" };

来看看初始化后的结果

• 那有同学问了，若是我不想按照顺序来进行初始化呢？可以吗？答案是可以的
• 只需要用[.]操作符然后选择对应的成员变量进行初始化即可

struct MyStruct ms2 = {.d = 6.28, .str = "abcdef", .c = 'cc'};		//乱序初始化

来看看这样初始化后的结果为多少。可以观察到没有被初始化到的变量就取为默认值，也就是这个【点】

三、结构体成员的访问

结构变量的成员是通过点操作符[.]访问的。点操作符接受两个操作数

• 这一点我们上面已经使用过了，就不多说，主要再介绍一种使用[->]操作符的形式进行访问，这一点我们在指针章节就有说到过，所以我们可以可以称其为结构体指针
• 有时候我们得到的不是一个结构体变量，而是指向一个结构体的指针。例如下面将一个结构体变量的地址给到一个结构体指针的，那就可以通过这个结构体指针去访问到这个结构体变量的成员了

struct Stu
{
	char name[20];
	int age;
};

int main(void)
{
	struct Stu s1 = { "zhangsan", 20 };
	printf("普通形式访问：%s %d\n\n", s1.name, s1.age);

	struct Stu* ss = &s1;
	printf("指针形式：%s %d\n", ss->name, ss->age);

	return 0;
}

• 那可以访问了，可不可以去进行一个修改呢？当然是可以的
• 例如下面又定义了一个结构体，然后通过乱序的方式去进行了一个初始化

struct S {
	char name[20];
	int age;
};

int main(void)
{
	struct S s = { .age = 22, .name = "zhangsan" };
}

• 下面是对成员变量进行修改的方式，你觉得正确吗？对于s.age = 30；来说是没有问题的，但是呢对于姓名的修改来说其实是存在问题的，在数组章节我们有说到过对于【数组名】来说指的就是首元素地址

s.age = 30;
s.name = "zhangsanfeng";

• 所以单单拿到一个数组的首元素地址，是无法对整个字符数组进行一个修改的，要么通过指针的形式遍历这个字符串做一一修改，不过这里我想要从整体的修改那么就得使用到一个有关字符串的库函数strcpy，不了解的可以去学习一下

strcpy(s.name, "zhangsanfeng");

四、结构体内存对齐【⭐】

1、前言

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

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

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，它可以==用来计算结构体成员相对于起始位置的偏移量==

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

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个空间的废位置
  

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

2、规则介绍

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

例题的分解与细说

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

• 假设我这里创建一个结构体变量叫做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】的位置就行
• [x] 那截止目前为止这个结构体中的所有成员变量都放置完了，此时去计算一个所占的内存空间就可以发现只有9个字节。但是在一开始我们计算的这个结构体的大小为12个字节，可是现在还差3个字节，所以最后就要去进行一个填充。但是，为什么呢？

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

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

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

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

3、习题演练

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

练习①

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

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】来验证一下

练习②

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

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的地址处
• [x] 然后来算整个结构体s4的大小，为所有最大对齐数（含嵌套结构体的对齐数）的整数倍，也就是取s3和s4中的最大对齐数，那也就是【8】，计算一下结构体s4所占的内存空间为32，刚好为8的整数倍，所以整个结构体的大小即为32

运行结果如下：

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

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

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

① 平台原因(移植原因)

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

② 性能原因

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

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

总体来说：

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

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

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

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

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

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

5、如何修改默认对齐数

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

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

#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】再来验证一下

结论：

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

6、实战演练

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

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

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

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

• 那要如何去实现呢？如果对宏不是很了解的读者可以看看 详解程序环境和预处理

• 我们通过上面的结构体S1进行讲解。列出3个成员变量放置的初始地址，其实【offsetof】计算的也就是每个变量在内存中的起始地址相较于首地址偏移了多少，那将它们进行一个相减就可以得出0、4、8这三个结果

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

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

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

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

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

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

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

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

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

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

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

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

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

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

下面是流程图：

下面是运行结果：

💬两道高频面试题

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

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

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

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

小结

【总结一下】

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

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

• 有了规则之后，将它们灵活地运用到实际的题目中，只要掌握了方法，就感觉其实计算结构体的大小也没有那么复杂，就是对于【嵌套结构体】的规则有些复杂，要考虑到另一个结构体中的最大对齐数

• 接下去，我们就谈到了为什么在计算这些结构体的时候会存在内存对齐的现象，对于了设置与不设置内存对齐便观察到这是【空间换时间】的做法

• 谈了很久的offsetof()，但是不清楚原理是什么👉这不，百度笔试题就考到了，于是我们就去自己通过一个宏实现了一下这个偏移量的求解，虽然过程很复杂，但是在我一步步的细讲下，相信聪明的你一定有所理解😁在理解了结构体内存对齐的各方面之后，面对两道面试题也是毫不畏惧💪

五、结构体传参

最后我们再来说说有关结构体的传参

直接上代码💻

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 函数哪个好些？

• [x] 答案是：首选print2函数
• 原因：函数传参的时候，参数是需要压栈的。如果传递一个结构体对象的时候，因为形参是实参的一份临时拷贝，实参传递过来的结构体有多大，形参也要开辟一块同样大小的空间来存放这个结构体，此时若是结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。
• 但若是我们只传递这个结构体的地址过去的话，函数内部便可以使用结构体指针访问到所有的内容，以便节省开销

——> 如果不了解这一块的可以看看我的函数栈帧一文

【总结一下】：
结构体传参的时候，要传结构体的地址

以上就是本文要介绍的所有内容，感谢您的阅读:rose: