广州红包印刷:C 中字节对齐杂谈

1. 字节对齐（byte alignment）：

现代计算机中内存空间都是按照byte划分的，从理论上讲对于任何类型的变量的访问都可以从任何地址开始。但是实际情况是在访问特定类型变量的时候经常在特定的内存地址访问，这就需要各种类型数据按照一定的规则在空间上排列，而不是顺序的一个接一个的牌坊，这就是对齐。

2. 对齐原因：

(1)有些CPU访问没有对齐的变量时候会发生错误。比如Motorola 68000不允许将16位的字存储到奇数地址中， 将一个16位的字写到奇数地址将引发异常。

(2)不对数据进行对齐，会在存取效率上带来损失。比如：有些CPU从偶数地址存储int数据，读取时需要一个机器周期，从偶数地址存储，就需要2个机器周期。

3.对齐规则：

实际上， 对于c中的字节组织， 有这样的对齐规则:   

(1) 结构体变量的首地址能够被其最宽基本类型成员的大小所整除；

(2) 结构体每个成员相对于结构首地址的偏移量（offset）都是成员大小的整数倍，如有需要编译器会在成员之间加上填充字节（internal adding）；

(3) 结构体的总大小为结构体最宽基本类型成员大小的整数倍，如有需要编译器会在最末一个成员之后加上填充字节（trailing padding）。

不同CPU的对其规则可能不同， 请参考手册。为什么会有上述的限制呢? 理解了内存组织， 就会清楚了。

CPU通过地址总线来存取内存中的数据，32位的CPU的地址总线宽度既为32位置， 标为A[0:31]。在一个总线周期内，CPU从内存读/写32位。 但是CPU只能在能够被4整除的地址进行内存访问，这是因为: 32位CPU不使用地址总线的A1和A2(比如ARM，它的A[0:1]用于字节选择， 用于逻辑控制， 而不和存储器相连，存储器连接到A[2:31])。访问内存的最小单位是字节(byte)， A0和A1不使用， 那么对于地址来说， 最低两位是无效的，所以它只能识别能被4整除的地址了。 在4字节中，通过A0和A1确定某一个字节。

4. 字节对齐对程序的影响：

（32bit、x86、gcc）（所占字节数char:1, short:2, int:4, long:4, float:4, double:8）

struct A

{

    int a;

    char b;

    short c;

};

struct B

{

    char b;

    int a;

    short c;

};

sizeof(strcut A) == 8

sizeof(struct B) == 12

5.修改默认对齐：

(1)编程时，使用#pragma pack()。

#pragma pack (2)                          /*指定按2字节对齐*/

struct C

{

    char b;

    int a;

    short c;

};

#pragma pack ()                           /*取消指定对齐，恢复缺省对齐*/

sizeof(strcut C) == 8 == 2(b) + 4(a) + 2(c)

(2)修改编译器的默认对齐方式。

6.编程注意情况：

(1)为了字节对齐，显示声明冗余变量。当然，不冗余声明，编译器也会自动对齐。

struct A

{

    char a;

    char reserved[3];                     /*使用空间换时间*/

    int b;

};

(2)带来隐患，尤其是对代码移植的影响。

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型变量，显然不符合对齐的规定。

由于编译器的不同，对于四字节对齐的定义就不同，有的编译器会自动补齐成四字节，有的不会。这样会造成交叉编译时不兼容。因此在设计数据结构时，应该尽量设计成4字节的倍数。
例如：
struct st
{
char string1[10];
int i;
char ch;
char string2[10];
}
这样是不太好的，有的编译器会自动给i和ch分别补齐为4字节。
好的设计应该是：
struct st
{
char string1[12];
char string2[12];
int i;
char ch;
char ch2;
}
这样无论是什么编译器都不会出现对其的问题，有工作经验的人在设计时都会比较注意这些。

=========================================================

为了能使CPU对变量进行高效快速的访问，变量的起始地址应该具有某些特性，   
   即所谓的“对齐”。例如对于4字节的int类型变量，其起始地址应位于4字节边界上，   
   即起始地址能够被4整除。变量的对齐规则如下（32位系统）：   
    
    
   Type   
   Alignment   
    
   char   
   在字节边界上对齐   
    
   short    (16-bit)   
   在双字节边界上对齐   
    
   int    and    long    (32-bit)   
   在4字节边界上对齐   
    
   float   
   在4字节边界上对齐   
    
   double   
   在8字节边界上对齐   
    
    
    
   structures   
   单独考虑结构体的个成员，它们在不同的字节边界上对齐。   
   其中最大的字节边界数就是该结构的字节边界数。   
   MSDN原话：Largest    alignment    requirement    of    any    member   
   理解结构体的对齐方式有点挠头，如果结构体中有结构体成员，   
   那么这是一个递归的过程。   
   对齐方式影响结构体成员在结构体中的偏移设编译器设定的最大对齐字节边界数为n，   
   对于结构体中的某一成员item，它相对于结构首地址的实际字节对齐数目X应该满足   
   以下规则：   
    
   X    =    min（n，    sizeof（item））   
    
   例如，对于结构体    struct    {char    a;    int    b}    T;   
    
   当位于32位系统，n=8时：   
   a的偏移为0，   
   b的偏移为4，中间填充了3个字节,    b的X为4；   
    
   当位于32位系统，n=2时：   
   a的偏移为0，   
   b的偏移为2，中间填充了1个字节，b的X为2；   
    
   结构体的sizeof   
   设结构体的最后一个成员为LastItem，其相对于结构体首地址的   
   偏移为offset（LastItem），其大小为sizeof(LastItem)，结构体的字节对齐数为N，   
   则：结构体的sizeof    为：    若offset（LastItem）＋    sizeof(LastItem)能够被N整除，   
   那么就是offset（LastItem）＋    sizeof(LastItem)，否则，在后面填充，   
   直到能够被N整除。   
    
   例如：32位系统，n=8，   
   结构体    struct    {char    a;    char    b;}    T;   
   struct    {char    a;    int    b；}    T1;   
   struct    {char    a;    int    b；    char    c;}    T2;   
   sizeof(T)    ==    2;    N    =    1    没有填充   
   sizeof(T)    ==    8;    N    =    4    中间填充了3字节   
   sizeof(T2)==12；    N    =    4    中间，结尾各填充了3字节   
    
   注意：   
    
   1）    对于空结构体，sizeof    ＝＝    1；因为必须保证结构体的每一个实例在内存中都   
   有独一无二的地址。   
    
   2）    结构体的静态成员不对结构体的大小产生影响，因为静态变量的存储位置与   
   结构体的实例地址无关。   
    
   例如：   
    
   struct    {static    int    I;}    T;    struct    {char    a;    static    int    I;}    T1;   
   sizeof(T)    ==    1;    sizeof(T1)    ==    1;   
    
   3)    某些编译器支持扩展指令设置变量或结构的对齐方式，如VC，   
       详见MSDN（alignment    of    structures）   
    
   以下为Linux内核代码中的例子:   
    
   __attribute__((regparm(0)))    int    printk(const    char    *    fmt,    ...)\   
     __attribute__    ((format    (printf,    1,    2)));   
   禁止printk使用寄存器传递调用参数，并将printk的参数1作为printf格式串，   
   从参数2开始检查其类型；   
    
   void    __switch_to(struct    task_struct    *prev,    struct    task_struct    *next)\   
     __attribute__((regparm(3)))    ;__switch_to保留3个寄存器用作传递参数；   
    
   void    __attribute__    ((__section__    (".text.init")))    mem_init();   
   将mem_init编绎到.text.init段；   
    
   struct    tasklet_head    tasklet_vec[32    ]\   
     __attribute__((__aligned__((32)),__section__(".data.cacheline_aligned")))    ;   
   将tasklet_vec[32]编绎到.data.cacheline_aligned段，并将它在32字节边界上对齐；   
    
   void    do_exit(long    error_code)__attribute__((noreturn));do_exit不会返回；   
    
   struct    Xgt_desc_struct    {    unsigned    short    size;    unsigned    long\   
   address    __attribute__((packed));};将address在结构中紧凑排列。