C语言字节对齐

转载地址：http://blog.csdn.net/21aspnet/article/details/6729724

详细介绍见上文链接

简记3种常用对齐方式如下：

以如下结构体作对比说明（默认4字节对齐）
struct stu {
        short s;        //2
        int i;          //2+2+4=8
        char c1;        //8+1=9 
        char c2;        //9+1=10
        char buf[7];    //10+7=17
};                      //17+3=20    //结构4字节对齐，补3

1. 伪指令
#pragma pack (n)，C编译器将按照n个字节对齐；如果结构中有成员的长度大于n，成员和结构仍然按照n作对齐；如果结构中有成员的长度小于n，则成员自然对齐，结构按照最大成员的长度来作对齐。
#pragma pack ()，取消自定义字节对齐方式。

 //成员和结构按1对齐
#pragma pack(1)  
struct stu_pra {
        short m;            //2
        int n;                  //2+4=6    //不补
        char c1;            //6+1=7
        char c2;             //7+1=8
        char buf[7];        //8+7=15
};                               //15             //不补
#pragma pack()

//成员自然对齐，结构按最大成员4对齐
#pragma pack(8)
struct stu_pra {
        short m;        //2
        int n;             //2+2+4=8    //按int=4对齐，补2
        char c1;        //8+1=9
        char c2;        //9+1=10
        char buf[7];    //10+7=17
};                            //17+3=20    //结构4字节对齐，补3
#pragma pack()


2. __attribute((aligned (n)))，让所作用的结构成员对齐在n字节自然边界上；如果结构中有成员的长度大于n，则成员自然对齐，结构按照最大成员的长度来作对齐；如果结构中有成员的长度小于n，则成员自然对齐，结构按照n来作对齐。
//成员自然对齐，结构按最大成员4对齐
struct stu_ali {
        short s;                                //2
        int i;                                      //2+2+4=8    //按int=4对齐，补2
        char c1;                                //8+1=9
        char c2;                                //9+1=10
        char buf[7];                            //10+7=17
}__attribute__((aligned(1)));        //17+3=20    //结构按照最大成员4补齐，补3

//成员自然对齐，结构按n=8对齐
struct stu_ali {
        short s;                            //2
        int i;                                 //2+2+4=8        //按int=4对齐，补2
        char c1;                            //8+1=9
        char c2;                            //9+1=10
        char buf[7];                      //10+7=17
}__attribute__((aligned(8)));     //17+7=24        //结构按n=8对齐，补7


 3. __attribute__ ((packed))，取消结构在编译过程中的优化对齐，按照实际占用字节数进行对齐。
//成员和结构都按最小字节1对齐
struct stu_pac {
        short s;                        //2
        int n;                            //2+4=6        //不补
        char c1;                        //6+1=7
        char c2;                        //7+1=8
        char buf[7];                    //8+7=15
}__attribute__((packed));                        //不补