结构体（3）

1.内存对齐

我们先直接来看一串代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
struct add
{
	char a;
	int b;
	double c;
}s1;
int main(void)
{
	printf("%d\n", sizeof(s1));
	return 0;
}

打印结果是16

但是char类型的值是1个字节大小

int类型的值是4个字节大小

double类型的值是8个字节大小

8+4+1=13为啥打印结果是16呢？

这就涉及到结构体的内存对齐了

我们在了解内存对齐前要先了解一个宏offsetof

它的头文件是#include <stddef.h>

offsetof (type,member)

Return member offset

参数是成员类型

返回值是该类型的偏移值

因此我们可以通过这个宏去判断

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stddef.h>
struct add
{
	char a;
	int b;
	double c;
};
int main(void)
{
	struct add s1 = { 0 };
	printf("%zd\n", offsetof(struct add,a));
	printf("%zd\n", offsetof(struct add,b));
	printf("%zd\n", offsetof(struct add,c));
	return 0;
}

结果是0 4 8

因此我们可以把这个结构体的内存存储方式画出来

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
a				b	b	b	b	c	c	c	c	c	c	c	c

我们这个时候会发现123这三个空间没有被使用

刚好是16个空间和第一个代码的结果一样

再来看一串代码

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stddef.h>
struct add
{
	char a;
	int b;
	char c;
};
int main(void)
{
	struct add s1 = { 0 };
	printf("%zd\n", sizeof(s1));
	printf("%zd\n", offsetof(struct add,a));
	printf("%zd\n", offsetof(struct add,b));
	printf("%zd\n", offsetof(struct add,c));
	return 0;
}

打印结果是12 0 4 8

0	1	2	3	4	5	6	7	8	9	10	11
a				b	b	b	b	c

这个地方我们发现2 3 9 10 11 12 这些空间都没用，明明给8个空间就够了啊，为啥还要多给4个空间不用呢？

这就涉及到对齐规则了

2.对齐规则

首先得掌握结构体的对齐规则：

1.结构体的第一个成员对齐到和结构体变量起始位置偏移量为0的地址处

2.其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

对齐数= 编译器默认的一个对齐数与 该成员变量大小的较小值.

-vs中默认的值为8

-Linux中gcc没有默认对齐数，对齐数就是成员自身的大小

3.结构体总大小为最大对齐数（结构体中每个成员变量都有一个对齐数，所有对齐数中最大的）的整数倍。

4.如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整教倍。 

看起来好像挺复杂的样子

没事就拿上面的题

char a;
int b;
char c;

带大家做一遍

首先结构体第一个成员的偏移量是0，a是char类型大小是一个字节

占一个格子

再看int b

根据

对齐数= 编译器默认的一个对齐数与 该成员变量大小的较小值.

vs中默认的值为8

int 类型的值占4个字节小于vs默认的8

可以知道第二个成员也就是int b的对其数是4

根据

其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

可以知道b的偏移量必须是4的整数倍

因此b的偏移量便是4 (满足且离a所处空间最近)

b是int类型大小，因此占4个格子，b结束的位置偏移量是9

char  类型的值占1个字节小于vs默认的8

可以知道第三个成员也就是int b的对其数是1

可以知道c的偏移量必须是1的整数倍

因此c的偏移量刚好在b结束的地方，也就是偏移量为9

最后再根据

结构体总大小为最大对齐数（结构体中每个成员变量都有一个对齐数，所有对齐数中最大的）的整数倍。

最大对齐数是4，因此结构体大小需是对齐数的整数倍，此时结构体大小是9，因此最后要空3个格子去满足最后一个要求

这也就是为啥结构体的空间分布这么奇怪了。

我们在最后再来一个例题去练习一遍

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stddef.h>
struct add
{
	double a;
	char b;
	int c;
	
};
struct bdd
{
	char d;
	struct add e;
	double f;
};
int main(void)
{
	struct bdd s1 = { 0 };
	printf("%zd\n", sizeof(s1));
	printf("%zd\n", offsetof(struct bdd,d));
	printf("%zd\n", offsetof(struct bdd,e));
	printf("%zd\n", offsetof(struct bdd,f));
	return 0;
}

打印结果是32 0 8 24

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20	21	22	23	24	25	26	27	28	29	30	31
d								e	e	e	e	e	e	e	e	e	e	e	e	e	e	e	e	f	f	f	f	f	f	f	f

z这个地方就涉及到内存对齐的最后一条了 

如果嵌套了结构体的情况，嵌套的结构体成员对齐到自己的成员中最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体中成员的对齐数）的整教倍。 

上面那串代码，嵌套的结构体成员是struct add e

它的大小是16个字节的空间

但是它的对齐数确是它自身成员的最大对齐数，也就是8

这个地方嵌套的结构体成员的对齐数并不是和vs默认的值去比较

而是直接对齐到自己的成员中最大对齐数的整数倍处(也就是8的倍数处)

这也就可以解释

printf("%zd\n", offsetof(struct bdd,e));

的值为什么是8了

3.那么为什么存在内存对齐呢？

1.平台原因（移植原因）：
不是所有的硬件平台都能访问任意地址上的任意数据的，某些硬件平台只能在某些地址处取某些特定类型的数据。
否则抛出硬件异常。

2.性能原因：
数据结构（尤其是栈)应该尽可能地在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要作两次内存访间；而对齐的内存访问仅需要一次访问。

假设一个处理器总是从内存中取8个字节，则地址必须是8的倍效。如果我们能保证将所有的double类型的数据的地址都对齐成8的倍数，那么就可以用一个内存操作来读或者写值了。

否则，我们可能需要执行两次内存访问，因为对象可能被分放在两个8字节内存块中。
总体来说：结构体的内存对齐是拿空间来换取时间的做法。

那在设计结构体的时候，我们既妻演足对齐，又要节肯空间，如何做到:
让占用空间小的成员尽量集中在开具 

4.如何自己设置默认对其数

vs上默认对齐数是8

那我们还可以去自己设置一个默认对齐数

我们直接上代码

#pragma pack(1)//设置默认对齐数为1
struct add
{
	double a;
	char b;
	int c;
	
};
#pragma pack()//取消设置的对齐数，恢复为默认

当然#pragma等我们学宏的时候还要用到，今天就先讲到这了。

最后再补充一下数组的默认对齐数

比如一个char[5]类型的数组，相当于5个char类型的值，但是默认对齐数和char

类型的是相同的，是1。