字节对齐总结

结构体（联合）字节对齐规则：

每个特定平台上的编译器都有自己的默认“对齐系数”(也叫对齐模数)。程序员可以通过预编译命令#pragma pack(n)，n=1,2,4,8,16 来改变这一系数，其中的n就是你要指定的“对齐系数”。
规则：

（一）成员字节对齐
1、普通数据成员对齐规则：结构(struct)(或联合(union))的数据成员，第一个数据成员放在offset为0的地方，以后每个数据成员的对齐 按照#pragma pack指定的数值和这个数据成员自身长度中，比较小的那个进行。

2.复杂（结构体、联合）数据成员对齐规则：结构体成员的结构中的所有成员最大对齐字节数与本结构体#pragma pack指定的数值，比较小的那个进行

（二）结构体整体字节对齐（圆整）
1、不含复杂结构的结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐(圆整)，按最大字节对齐数进行圆整（对齐将按照#pragma pack指定的 数值和结构(或联合)最大数据成员长度中，比较小的那个进行）。

2、含有复杂结构的结构(或联合)的整体对齐规则：在数据成员完成各自对齐之后，结构(或联合)本身也要进行对齐(圆整)，按结构体（包括复杂结构中的成员）中最大字节对齐数与本结构体中#pragma pack指定的数值较小的那个数行圆整。
3、当#pragma pack的n值等于或超过所有数据成员长度的时候，这个n值的大小将不产生任何效果。

/*************************************************************/

此部分为转载：http://eriol.iteye.com/blog/1004580

Cpp代码  

1. class CBase   
2. {   
3. };

    结果：sizeof(CBase)=1。

为什么空的什么都没有的类的大小是1呢？

c++要求每个实例在内存中都有独一无二的地址。

空类也会被实例化，所以编译器会给空类隐含的添加一个字节，这样空类实例化之后就有了独一无二的地址了。所以空类的sizeof为1。

/****************************************************************************************/

测试代码：

（1）复杂（结构体、联合）数据成员对齐规则测试代码

#include <stdio.h>
#pragma pack(4)
class S1
{
public:
char a;
double b;
char c;
};


#pragma pack(2)
class A
{
public:
char c;
S1 d;
char e;
char f;
};


int main(int argc, char *argv[])
{
A test[2];
printf("&test[0].c = %p\n",&test[0].c);
printf("&test[0].d.a = %p\n",&test[0].d.a);  
printf("&test[0].d.b = %p\n",&test[0].d.b);  
printf("&test[0].d.c = %p\n",&test[0].d.c);  
printf("&test[0].e = %p\n",&test[0].e);
printf("&test[0].f = %p\n",&test[0].f);
printf("&test[1].c = %p\n",&test[1].c);
printf("sizeof(S1) = %d\n",sizeof(S1));
printf("sizeof(A) = %d\n",sizeof(A));

return 0;
}

结果：

d按2字节进行对齐（S1 成员最在字节对齐数为4，A结构#pragma pack指定值为2，所以d按2字节对齐）

#include <stdio.h>
#pragma pack(4)
class S1
{
public:
char a;
double b;
char c;
};


#pragma pack(8)
class A
{
public:
char c;
S1 d;
char e;
char f;
};


int main(int argc, char *argv[])
{
A test[2];
printf("&test[0].c = %p\n",&test[0].c);
printf("&test[0].d.a = %p\n",&test[0].d.a);  
printf("&test[0].d.b = %p\n",&test[0].d.b);  
printf("&test[0].d.c = %p\n",&test[0].d.c);  
printf("&test[0].e = %p\n",&test[0].e);
printf("&test[0].f = %p\n",&test[0].f);
printf("&test[1].c = %p\n",&test[1].c);
printf("sizeof(S1) = %d\n",sizeof(S1));
printf("sizeof(A) = %d\n",sizeof(A));

return 0;
}

结果：

d按4字节进行对齐（S1 成员最在字节对齐数为4，A结构#pragma pack指定值为8，所以d按4字节对齐）

（2）含有复杂结构的结构(或联合)的整体对齐规则测试代码

#include <stdio.h>
#pragma pack(8)
class S1
{
public:
char a;
double b;
char c;
};


#pragma pack(8)
class A
{
public:
char c;
S1 d;
char e;
char f;
};


int main(int argc, char *argv[])
{
A test[2];
printf("&test[0].c = %p\n",&test[0].c);
printf("&test[0].d.a = %p\n",&test[0].d.a);  
printf("&test[0].d.b = %p\n",&test[0].d.b);  
printf("&test[0].d.c = %p\n",&test[0].d.c);  
printf("&test[0].e = %p\n",&test[0].e);
printf("&test[0].f = %p\n",&test[0].f);
printf("&test[1].c = %p\n",&test[1].c);
printf("sizeof(S1) = %d\n",sizeof(S1));
printf("sizeof(A) = %d\n",sizeof(A));

return 0;
}

结果：

按8字节进行圆整

#include <stdio.h>
#pragma pack(8)
class S1
{
public:
char a;
double b;
char c;
};


#pragma pack(2)
class A
{
public:
char c;
S1 d;
char e;
char f;
};


int main(int argc, char *argv[])
{
A test[2];
printf("&test[0].c = %p\n",&test[0].c);
printf("&test[0].d.a = %p\n",&test[0].d.a);  
printf("&test[0].d.b = %p\n",&test[0].d.b);  
printf("&test[0].d.c = %p\n",&test[0].d.c);  
printf("&test[0].e = %p\n",&test[0].e);
printf("&test[0].f = %p\n",&test[0].f);
printf("&test[1].c = %p\n",&test[1].c);
printf("sizeof(S1) = %d\n",sizeof(S1));
printf("sizeof(A) = %d\n",sizeof(A));

return 0;
}

结果：

按2字节进行圆整