C语言中的字节对齐

下面这个篇博客讲解很好

http://blog.csdn.net/meegomeego/article/details/9393783

总的来看分三类：

1. 不加 #pragma pack(n）伪指令(n未对齐的字节数目)

2. 加#pragma pack(n) 伪指令

3. __attribute__((aligned(n)))来使用n个字节方式的对齐

 

第一种：不加 #pragma pack(n）伪指令

对其的字节数目为一个结构体中的基本类型(int char float double，特别强调复合型(数组、结构体、联合体)不算。)成员变量中最大的字节数(也可理解为默认对齐字节数，如char 默认 1字节 int 默认 4字节 等)。

第二种：加#pragma pack(n) 伪指令

对其的字节数目为一个结构体中的基本类型(int char float double，特别强调复合型(数组、结构体、联合体)不算。)成员变量最大的字节数(也可理解为默认对齐字节数，如char 默认 1字节 int 默认 4字节 等) 与pragma pack(n) 中的n值二者之间的较小数为对齐的字节数。比如：一个结构体中基本类型的

成员变量为 float a;//默认是4字节对齐，而加#pragma pack(8) 设置为8字节，此时加#pragma pack(8)设置失效，是4字节对齐(4 < 8)，如果 n 为 2，那么对齐的字节数就是2字节了(2 < 4)。

经典例子：

// 例3（如果在GCC中编译，请加上-malign-double选项）  
#pragma pack(8)  
struct s1  
{  
    short a; // 第一个成员，放在[0, 1]偏移的位置。  
    long  b; // 第二个成员sizeof(long)=4, #pragma pack(8), 取小值也就是4  
         // 所以这个成员按4字节对齐，放在偏移[4~7]的位置。  
};  
    // struct s1中size最大的数据成员(4), #pragma pack(8)  
    // 取小值也就是4，所以sizeof(struct s1)应当按照4来对齐，为8  
  
struct s2  
{  
    char      c; // 第一个成员，放在[0]偏移的位置。  
    struct s1 d; // 第二个成员为struct s1，其对齐方式是它的所有成员使用的对齐参数中最大的一个，即4。  
             // 所以第二个成员d按4字节对齐，由于sizeof(d)=8, 放在偏移[4~11]的位置。  
    long long e; // 第三个成员sizeof(long long)=8, #pragma pack(8), 取小值也就是8  
             // 所以这个成员按8字节对齐，放在偏移[16~23]的位置。  
};  
#pragma pack()  

第三种：__attribute__((aligned(n)))来使用n个字节方式的对齐

这种方式和第二种的方式是刚好相反的，取得是较大值来作为字节对齐。

经典例子：

#include <stdio.h>  
#include <stdlib.h>  
  
#pragma pack(16)  
struct testa  
{  
        unsigned int number;  
};  
#pragma pack()  
struct testa arr_testa[4] = { {65535}, {65535}, {65535}, {65535} };  
  
struct testb  
{  
        unsigned int number;  
} __attribute__ ((aligned (16))) ;  
  
struct testb arr_testb[4] = { {65535}, {65535}, {65535}, {65535} };  
  
  
int main(int argc, const char *argv[])  
{  
        printf("sizeof(struct testa) = %d, sizeof(arr_testa) = %d\n",  
                        sizeof(struct testa), sizeof(arr_testa));  
        printf("sizeof(struct testb) = %d, sizeof(arr_testb) = %d\n",  
                        sizeof(struct testb), sizeof(arr_testb));  
  
        printf("address of arr_testa[0] = %p\n", &arr_testa[0]);  
        printf("address of arr_testa[1] = %p\n", &arr_testa[1]);  
        printf("address of arr_testa[2] = %p\n", &arr_testa[2]);  
        printf("address of arr_testa[3] = %p\n", &arr_testa[3]);  
        puts("");  
        printf("address of arr_testb[0] = %p\n", &arr_testb[0]);  
        printf("address of arr_testb[1] = %p\n", &arr_testb[1]);  
        printf("address of arr_testb[2] = %p\n", &arr_testb[2]);  
        printf("address of arr_testb[3] = %p\n", &arr_testb[3]);  
        return 0;  
}  

输出结果为：

sizeof(struct testa) = 4, sizeof(arr_testa) = 16  
sizeof(struct testb) = 16, sizeof(arr_testb) = 64  
address of arr_testa[0] = 0x804a040  
address of arr_testa[1] = 0x804a044  
address of arr_testa[2] = 0x804a048  
address of arr_testa[3] = 0x804a04c  
  
address of arr_testb[0] = 0x804a060  
address of arr_testb[1] = 0x804a070  
address of arr_testb[2] = 0x804a080  
address of arr_testb[3] = 0x804a090 

 特别强调注意union 的字节对齐：

union AAA{
　　double i;//8B
       int  k[5];//20B
       cahr b; //1B 
}

上面的unionAAA类型，类型的字节大小为sizeof(AAA) ，按固有的原则来看，应该取AAA中长度最长的成员的程度。但是容易忽略一点就是字节对齐问题。综合考虑union类型的字节大小的求解，从如下两方面入手：

1. 找到占内长度最大的成员

2. 考虑字节对齐问题

union  AAA：

1. k[5] 占内存20字节最大

2. 最长的基本类型成员为double类型，占据8字节。故最后union AAA占用内存应该是8的倍数，20 + 4 即可。

sizeof(AAA)  = 24字节！