C语言精要总结-内存地址对齐与struct大小判断篇

时间 2019-12-08

标签 c语言总结内存地址对齐 struct 大小判断繁體版

原文原文链接

在笔试时，常常会遇到结构体大小的问题，实际就是在考内存地址对齐。在实际开发中，若是一个结构体会在内存中高频地分配建立，那么掌握内存地址对齐规则，经过简单地自定义对齐方式，或者调整结构体成员的顺序，能够有效地减小内存使用。另外，一些不用边界对齐、能够在任何地址（包括奇数地址）引用任何数据类型的的机器，不在本文讨论范围以内。linux

什么是地址对齐

计算机读取或者写入存储器地址时，通常以字（因系统而异，32位系统为4个字节）大小（N）的块来执行操做。数据对齐就是将数据存储区的首地址对齐字大小（N）的某个整数倍地址。为了对齐数据，有时须要在物理上相邻的两个数据之间保留或者插入一些无心义的字节。内存对齐本事编译器考虑是事情，但在C、C++语言中，能够人为修改对齐方式。windows

为何要地址对齐

计算机会保证存储器字的大小，至少要大于等于计算机支持的最大原始数据类型的大小。数组

这样，一个原始数据类型就必定能够存放在一个存储器字中，若是保证了数据是地址对齐的，那么访问一个原始数据就能够保证只访问一个存储器字，这有利于提升效率。以下图数据结构

反之，若是一个数据不是按字大小内存对齐的（也就是最高字节与最低字节落在两个字中），那么，这个数据极可能落在两个存储器字中。以下图并发

这时，计算机必须将数据访问分割成多个存储器字访问，这须要更多复杂的操做。甚至，当这两个字都不存在一个存储器页中是，处理器还必须在执行指令以前验证两个页面是否存在，不然可能会发生未命中错误。另外，对一个存储器字的操做是原子的，若是拆分红两次访问，也可能引起一些并发问题，好比从两个字读出来的数据段拼起来可能不是真实的数据，由于有另外的设备在写。tcp

起始地址约束（对齐系数）

C++11 引入 alignof 运算符，该运算符返回指定类型的对齐系数（以字节为单位），其中宏__alignof在linux gcc或者windows都有定义。ide

下面一段程序取几个经常使用的基本数据类型。函数

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 int main(){
 4      printf("char: %d\n",__alignof(char));
 5      printf("short: %d\n",__alignof(short));
 6      printf("int: %d\n",__alignof(int));
 7      printf("long: %d\n",__alignof(long));
 8      printf("double: %d\n",__alignof(double));
 9      return 0;
10 }

分别在linux和windows下编译运行，获得以下结果性能

类型	Linux	Windows
char	1	1
short	2	2
int	4	4
long	8	4
double	8	8

能够看到Linux下与Windows下，long类型对齐系数不同。而且对齐系数与类型自身所占的大小也基本一致。测试

地址对齐对struct大小的影响

地址对齐主要影响到一些复杂的数据结构，好比struct结构体，由于有了内存地址对齐，大多数的struct实际占用的大小显得有些诡异。（注意，一个结构体的大小极可能超过存储器字大小，这时跨字读取数据已不可避免。但结构体自己及其成员仍是须要继续遵照对齐规则）

拿一个很简单的结构体align1为例

1 struct align1
2 {
3     char a;
4     int b;
5     char c;
6 } sim[2];

若是不考虑任何对齐问题，只考虑结构体中每一个成员应该占用的大小，很显然每一个结构align1定义的变量是1（char）+4（int）+1（char）共6个字节。可是实际上（至少在windows上）它占用了12个字节，缘由就在于它有按照必定的规则进行内存地址对齐。下面是笔者参考各方面资料总结的四点结构体边界对齐需知足的要点：

结构体变量自己的起始位置，必须是结构成员中对边界要求最严格（对齐系数最大）的数据类型所要求的位置
1. 好比double类型的起始地址约束（对齐系数）为8 ，那若是一个结构体包含double类型，则结构体变量自己的起始地址要能被8整除
成员必须考虑起始地址约束（对齐系数）和自己的大小，在windows和linux下，均可以使用__alignof(type)来查看type类型（原始基本类型）的起始地址约束（对齐系数）。
若是成员也是struct union之类的类型，则总体要照顾到部分，总体要知足成员能符合起始地址约束
结构体可能须要在其全部成员以后填充一些字节，以保证在分配结构体数组以后，每一个数组元素要知足起始地址约束。

让咱们再来仔细研究下结构体 align1定义的实例数组 sim[2]。咱们先约定：占用即表示自己大小及其后的空余空间。

按要点1，则sim[0]的起始地址必须能被4整除，假设这个其实地址是4n，其中成员a的起始地址也是sim[0]的起始地址（按要点2，由于a 为char类型，对齐系数为1，放哪均可以），a占用一个字节。

按要点2，成员b的起始地址必须能被4整除，很显然不能直接放在成员a的后面（起始地址是4n+1，不能被4整除），因此须要跳过3个字节存放b，那么成员a实际占用了4个字节（咱们的约定）。

同理，成员c能够直接放在b成员后面（起始地址是（4（n+2）），并且确定能够被1整除）。

至此，sim[0]已经占用了9个字节了，但按照要点4，由于数组是连续的，为了保证其后的数组成员sim[1]也符合首地址能被4整除，必须将sim[0]的空间前后延长3个字节至（4（n+3））。因此sim[0]实际要占用12个字节。

固然一个结构体不能有两个大小，哪怕其后再也不放align1类型的变量，系统也要为这个变量分配最大的12个字节空间。

用一个简单的占位符来表示存储，可表示为

1 // --sim[0]---- ----sim[1]--
2 // a---bbbbc--- a---bbbbc---

用图片描述如图（一个正方形表示一个字节空间）

很显然，这个结构体对空间利用率不高，有50%的空间浪费。经过调整成员定义的顺序，彻底能够优化空间利用。我的的经验是，自己占用空间大的（如double类型）应该尽可能往前面放。下面咱们将int b;调整到第一位定义

1 struct align2
2 {
3     int b;
4     char a;
5     char c;
6 } sim[2];

经过分析不难发现，新的结构占用8个字节的空间。如图

空间利用率提升到75%。当一个结构体足够复杂时，经过调整顺序或者自定义对齐方式，压缩带来的空间是很是可观的。虽然，随着内存越作越大，通常状况下开发已经不须要考虑这种问题。可是在海量服务下，如何死抠性能和减小资源占用依然是开发须要考虑的问题。就像如今单机几十万并发tcp链接已经不难作到，为何仍是有不少人在研究C10M（单机千万链接）。

下面的程序是基于以上四项要点作的测试，特别注意MyStruct7，由于其中的成员包含数组。至于成员包含union的就比较简单了，通常能够直接把union用union中最大的成员替换考虑，另外注意考虑要点3。另外，在一个位段定义中使用非int 、signed int 、或者unsigned int类型，位段定义将变成一个普通的结构体，对齐原则也就听从结构体的对齐原则。

 1 #include <stdio.h>
 2 #include <stdlib.h>
 3 #include <stddef.h>
 4 /************************************************************************/
 5 /* 这里约定：占用即表示自己大小及其后的空余空间
 6 /************************************************************************/
 7 struct MyStruct1    // 起始地址能被8整除
 8 {
 9     char a;            // 8
10     double b;        // 8
11     float c;        // 4
12     int d;            // 4
13 } m1;                // 24
14 
15 struct MyStruct2    // 起始地址能被8整除
16 {
17     int a;            // 4
18     float b;        // 4
19     char c;            // 8 // 后面 double的起始地址要能被8 整除，因此c补齐8个字节
20     double d;        // 8        
21 } m2;                // 24
22 
23 struct MyStruct3    // 起始地址能被8整除
24 {
25     short a;        // 2
26     char b;            // 6 // 同理，后面的元素的起始地址要能被 8 整除，因此b只要占用6
27     double c;        // 8
28     int d;            // 8 // 须要在其后填充一些字节，以保证在分配数组以后，每一个数组元素要知足起始地址约束
29 } m3;                // 24
30 
31 struct MyStruct4
32 {
33     char a;            // 2 // 能被4整除的地址 +2以后能被2整除，因此a只要补1个字节
34     short b;        // 2 
35     int c;            // 4
36 } m4;                // 8
37 
38 struct MyStruct5    // 起始地址能被8整除
39 {
40     double a;        // 8
41     float b;        // 4
42     int c;            // 4    
43     short d;        // 2
44     char e;            // 6 由于后面牢牢挨着的MyStruct5 变量（在分配数组的时候）起始地址也要能被8整除，因此这个结构体总的大小必须是8的整数倍
45 } m5;                // 24
46 
47 struct MyStruct6    // 除4对齐
48 {
49     short a;        // 2
50     char b;            // 2
51     long c;            // 4
52     short d;        // 4  // 保证数组后面的元素也符合规则 （结构体首地址能够除4）
53 } m6;                // 12
54 
55 struct MyStruct7    // 4 对齐
56 {
57     int a;            // 4
58     char b;            // 2
59     short c;        // 2
60     char d[6];        // 8
61 } m7;                    // 16
62 
63 int main(){
64     printf("m1 size : %d\n",sizeof m1);
65     printf("m2 size : %d\n",sizeof m2);
66     printf("m3 size : %d\n",sizeof m3);
67     printf("m4 size : %d\n",sizeof m4);
68     printf("m5 size : %d\n",sizeof m5);
69     printf("m6 size : %d\n",sizeof m6);
70     printf("m7 size : %d\n",sizeof m7);
71 
72     // offsetof 函数用来计算成员离结构体首地址偏移的字节数
73     printf("MyStruct1 b offset : %d\n",offsetof(struct MyStruct1,b));    // b偏移8个字节，因此成员a占用8个字节
74     printf("MyStruct2 d offset : %d\n",offsetof(struct MyStruct2,d));    // d偏移了16个字节 
75     printf("MyStruct3 c offset : %d\n",offsetof(struct MyStruct3,c));    // 偏移8
76     printf("MyStruct4 b offset : %d\n",offsetof(struct MyStruct4,b));    // 偏移2
77     printf("MyStruct5 e offset : %d\n",offsetof(struct MyStruct5,e));    // 偏移16
78     printf("MyStruct6 c offset : %d\n",offsetof(struct MyStruct6,c));    // 偏移4
79     printf("MyStruct7 c offset : %d\n",offsetof(struct MyStruct7,c));    // 偏移
80     system("pause");
81     return 0;
82 }

测试代码

文中所用的windows为windows7 64位， gcc版本为：gcc version 5.1.0 (tdm64-1)；linux为CentOSLinux release 7.2.1511 (Core)，gcc版本是gcc version 4.8.5 20150623 (Red Hat 4.8.5-11) (GCC)

参考文章：https://en.wikipedia.org/wiki/Data_structure_alignment