深入研究字节对齐问题

1.

对齐的原因与作用

1.1.

对齐的原因

各种硬件平台对存储空间的处理上有很大的不同。一些平台对某些特定类型的数据只能从某些特定地址开始存取。比如有些架构的
CPU

在访问一个没有进行对齐的变量的时候会发生错误，那么在这种架构下编程必须保证字节对齐。

1.2.

对齐的作用

最常见的情况是，如果不按照适合其平台要求对数据存放进行对齐，会在存取效率上带来损失。比如有些平台每次读都是从偶地址开始，如果一个
int

型（假设为
32

位系统）存放在偶地址开始的地方，那么一个读周期就可以读
32bit

，而如果存放在奇地址开始的地方，就需
2

个读周期，并对两次读出的结果的高低字节进行拼凑才能得到
32bit

数据。显然在读取效率上下降很多。

如果都按照该
cpu

对齐格式对齐了的话，可以大大减少
cpu

读周期的数目，明显提高了运算的效率。

在
x86

上，类似的操作只会影响效率，因为
x86

支持自动对齐。但是在
MIPS

或者
sparc

上，可能就是一个
error

，因为它们要求必须字节对齐。

2.

对齐的实现

通常，我们写程序的时候，不需要考虑对齐问题。编译器会替我们选择适合目标平台的对齐策略。当然，我们也可以通知给编译器传递预编译指令而改变对指定数据的对齐方法。

但是，如果我们从不关心这个问题，在有些情况下可能会出错。比如第三方库、
IPC

之间发送内存数据、二进制网络协议等等，有可能使用不同的编译器并设置不同的字节对齐方式，因此就有可能带来一些莫名其妙的错误，对于相同的结构体或类对象
sizeof

出来的大小可能差别很大。

3.

字节对齐对程序的影响

先让我们看几个例子吧
(32bit,x86

环境
,gcc

编译器

):

设结构体如下定义：

struct A

{

int a;

char b;

short c;

};

struct B

{

char b;

int a;

short c;

};

现在已知
32

位机器上各种数据类型的长度如下

:

char:1(

有符号无符号同

)

short:2(

有符号无符号同

)

int:4(

有符号无符号同

)

long:4(

有符号无符号同

)

float:4

double:8

那么上面两个结构大小如何呢

?

结果是

:

sizeof(strcut A)

值为

8

sizeof(struct B)

的值却是
12

结构体
A

中包含了
4

字节长度的
int

一个，
1

字节长度的
char

一个和
2

字节长度的
short

型数据一个
,B

也一样
;

按理说
A,B

大小应该都是
7

字节。

之所以出现上面的结果是因为编译器要对数据成员在空间上进行对齐。上面是按照编译器的默认设置进行对齐的结果
,

默认对齐设置为
4

字节。那么我们是不是可以改变编译器的这种默认对齐设置呢
,

当然可以
.

例如

:

#pragma pack (2) /*

指定按
2

字节对齐

*/

struct C

{

char b;

int a;

short c;

};

#pragma pack () /*

取消指定对齐，恢复缺省对齐

*/

sizeof(struct C)

值是
8

。

修改对齐值为
1

：

#pragma pack (1) /*

指定按
1

字节对齐

*/

struct D

{

char b;

int a;

short c;

};

#pragma pack () /*

取消指定对齐，恢复缺省对齐

*/

sizeof(struct D)

值为
7

。

后面我们再讲解
#pragma pack()

的作用。

4.

设置默认对齐值

4.1.

vc

设置方法

1.

在
VC IDE

中，可以这样修改：
[Project]|[Settings],c/c++

选项卡
Category

的
Code Generation

选项的
Struct Member Alignment

中修改，默认是
8

字节。

2.

在编码时，可以这样动态修改：
#pragma pack .

注意
:

是
pragma

而不是
progma

。

4.2.

gcc

设置方面

在代码中添加：
#pragma pack (

对齐字节值
)

。

5.

字节对齐规则

5.1.

基本概念

1.

数据类型自身的对齐值：

对于
char

型数据，其自身对齐值为
1

，对于
short

型为
2

，对于
int,float

类型，其自身对齐值为
4

，
double

为
8

，单位字节。

2.

结构体或者类的自身对齐值：
其成员中自身对齐值最大的那个值。

3.

指定对齐值
：
#pragma pack (value)

时的指定对齐值
value

。

4.

数据成员、结构体和类的有效对齐值：
自身对齐值和指定对齐值中小的那个值。

5.2.

对齐算法

有了这些概念，我们就可以很方便的来讨论具体数据结构的成员和其自身的对齐方式。有效对齐值
N

是最终用来决定数据存放地址方式的值，最重要。有效对齐
N

，就是表示
“

对齐在
N

上
”

，也就是说该数据的
"

存放起始地址
%N=0
"

。而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址就是数据结构的起始地址。结构体的成员变量要对齐排放，结构体本身也要根据自身的有效对齐值圆整
(

就是结构体成员变量占用总长度需要是对结构体有效对齐值的整数倍，结合下面例子理解
)

。

示例分析



示例一：



struct B

{

char b;

int a;

short c;

};

假设
B

从地址空间
0x0000

开始排放，默认字节对齐值为
4

。第一个成员变量
b

的自身对齐值是
1

，比指定或者默认指定对齐值
4

小，所以其有效对齐值为
1

，所以其存放地址
0x0000

符合
0x0000%1=0

。第二个成员变量
a

，其自身对齐值为
4

，所以有效对齐值也为
4

，

所以只能存放在起始地址为
0x0004

到
0x0007

这四个连续的字节空间中，复核
0x0004%4=0,

且紧靠第一个变量。第三个变量
c,

自身对齐值为
2

，所以有效对齐值也是
2

，可以存放在
0x0008

到
0x0009

这两个字节空间中，符合
0x0008%2=0

。所以从
0x0000

到
0x0009

存放的

都是
B

内容。再看数据结构
B

的自身对齐值为其变量中最大对齐值
(

这里是
b

）所以就是
4

，所以结构体的有效对齐值也是
4

。根据结构体圆整的要求，
0x0009

到
0x0000=10

字节，（
10

＋
2

）％
4

＝
0

。所以
0x0000A

到
0x000B

也为结构体
B

所占用。故
B

从
0x0000

到
0x000B

共有
12

个字节
,sizeof(struct B)=12

。

其实如果就这一个就来说它已将满足字节对齐了
,

因为它的起始地址是
0,

因此肯定是对齐的
,

之所以在后面补充
2

个字节
,

是因为编译器为了实现结构数组的存取效率。试想，如果我们定义了一个结构
B

的数组
,

那

么第一个结构起始地址是
0

没有问题
,

但是第二个结构呢
?

按照数组的定义
,

数组中所有元素都是紧挨着的
,

如果我们不把结构的大小补充为
4

的整数倍
,

那么下一

个结构的起始地址将是
0x0000A,

这显然不能满足结构的地址对齐了
,

因此我们要把结构补充成有效对齐大小的整数倍。其实诸如
:

对于
char

型数据，其自身对齐值为
1

，对于
short

型为
2

，对于
int,float

类型，其自身对齐值为
4

，这些已有类型的自身对齐值也是基于数组考虑的，只是因为这些类型的长度已知了
,

所以他们的自身对齐值也就已知了。

再分析一个：



#pragma pack (2) /*

指定按
2

字节对齐

*/

struct C

{

char b;

int a;

short c;

};

#pragma pack () /*

取消指定对齐，恢复缺省对齐

*/

第一个变量
b

的自身对齐值为
1

，指定对齐值为
2

，所以，其有效对齐值为
1

，假设
C

从
0x0000

开始，那么
b

存放在
0x0000

，符合
0x0000%1= 0;

第二个变量，自身对齐值为
4

，指定对齐值为
2

，所以有效对齐值为
2

，所以顺序存放在
0x0002

、
0x0003

、
0x0004

、
0x0005

四个连续

字节中，符合
0x0002%2=0

。第三个变量
c

的自身对齐值为
2

，所以有效对齐值为
2

，顺序存放在
0x0006

、
0x0007

中，符合
0x0006%2=0

。所以从
0x0000

到
0x00007

共八字节存放的是
C

的变量。又
C

的自身对齐值为
4

，所以
C

的有效对齐值为
2

。又
8%2=0,C

只占用
0x0000

到
0x0007

的八个字节。所以
sizeof(struct C)=8

。

5.3.

其他细节

1
、数组的自身对齐值为元素对齐值。

2
、嵌套结构体对齐值为打散后内部最大的对齐值。

3
、x86
中有个设置是否检查字节对齐的选项，但是windows
都没有设置这个选项，缺省为0
（不检查，自动对齐）。

4
、单个简单数据类型，如int
、long
、double
等字节对齐大小不受编译器影响。

5
、当数组作为函数的参数进行传递时，该数组自动退化为同类型的指针，sizeof
大小为4
。

6.

在程序中处理字节对齐问题

1

）代码中关于对齐的隐患，很多是隐式的。比如在强制类型转换的时候。

例如：

unsigned int i = 0x12345678;

unsigned char *p=NULL;

unsigned short *p1=NULL;

p=&i;

*p=0x00;

p1=(unsigned short *)(p+1);

*p1=0x0000;

最后两句代码，从奇数边界去访问
unsigned short

型变量，显然不符合对齐的规定。

2

）如果在编程的时候要考虑节约空间的话
,

那么我们只需要假定结构的首地址是
0,

然后各个变量按照上面的原则进行排列即可
,

基本的原则就是把结构中的变量按照类型大小从大到小声明
,

尽量减少中间的填补空间。还有一种就是为了以空间换取时间的效率
,

我们显示的进行填补空间进行对齐
,

比如
:

有一种使用空间换时间做

法是显式的插入
reserved

成员：

struct A{

char a;

char reserved[3];//

使用空间换时间

int b;

}

reserved

成员对我们的程序没有什么意义
,

它只是起到填补空间以达到字节对齐的目的
,

当然即使不加这个成员通常编译器也会给我们自动填补对齐
,

我们自己加上它只是起到显式的提醒作用。