結構體對齊詳解

許多實際的計算機系統對基本類型數據在內存中存放的位置有限制，它們會要求這些數據的起始地址的值是某個數k的倍數，這就是所謂的內存對齊，而這個k則被稱爲該數據類型的對齊模數(alignment modulus)。這種強制的要求一來簡化了處理器與內存之間傳輸系統的設計，二來可以提升讀取數據的速度。
比如這麼一種處理器，它每次讀寫內存的時候都從某個8倍數的地址開始，一次讀出或寫入8個字節的數據，假如軟件能保證double類型的數據都從8倍數地址開始，那麼讀或寫一個double類型數據就只需要一次內存操作。否則，我們就可能需要兩次內存操作才能完成這個動作，因爲數據或許恰好橫跨在兩個符合對齊要求的8字節內存塊上。 1)結構體總長度；
2)結構體內各數據成員的內存對齊，即該數據成員相對結構體的起始位置； 1)將結構體內所有數據成員的長度值相加，記爲sum_a；
2)將各數據成員爲了內存對齊，按各自對齊模數而填充的字節數累加到和sum_a上，記爲sum_b。對齊模數是#pragma pack指定的數值以及該數據成員自身長度中數值較小者。該數據相對起始位置應該是對齊模式的整數倍;
3)將和sum_b向結構體模數對齊，該模數是【 #pragma pack指定的數值】、【 未指定#pragma pack時，系統默認的對齊模數（32位系統爲4字節，64位爲8字節）】和【 結構體內部最大的基本數據類型成員】長度中數值較小者。結構體的長度應該是該模數的整數倍。 在計算之前，我們首先需要明確的是各個數據成員的對齊模數，對齊模數和數據成員本身的長度以及pragma pack編譯參數有關，其值是二者中最小數。如果程序沒有明確指出，就需要知道編譯器默認的對齊模數值。下表是Windows XP/DEV-C++和Linux/GCC中基本數據類型的長度和默認對齊模數。

		char	short	int	long	float	double	long long	long double
Win-32	長度	1	2	4	4	4	8	8	8
	模數	1	2	4	4	4	8	8	8
Linux-32	長度	1	2	4	4	4	8	8	12
	模數	1	2	4	4	4	4	4	4
Linux-64	長度	1	2	4	8	4	8	8	16
	模數	1	2	4	8	4	8	8	16

例子1：

struct my_struct { 
    char a; 
    long double b; 
};

此例子Windows和Linux計算方法有些許不一致。
在Windows中計算步驟如下：
步驟1：所有數據成員自身長度和：1B + 8B = 9B --> sum_a = 9B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是8，之前需填充7個字節，sum_a + 7 = 16B --> sum_b = 16 B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲8後者爲4，所以結構體對齊模數是4。sum_b是4的4倍，不需再次對齊。
綜上3步，可知結構體的長度是16B，各數據成員在內存中的分佈如圖1-1所示。

在Linux中計算步驟如下：
步驟1：所有數據成員自身長度和：1B + 12B = 13B --> sum_a = 13B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是4，之前需填充3個字節，sum_a + 3 = 16B --> sum_b = 16 B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲12後者爲4，所以結構體對齊模數是4。sum_b是4的4倍，不需再次對齊。
綜上3步，可知結構體的長度是16B，各數據成員在內存中的分佈如圖1-2所示。



例子2：

#pragma pack(2) struct my_struct 
{ 
    char a; 
    long double b; 
}; 
#pragma pack()

例子1和例子2不同之處在於例子2中使用了#pragma pack(2)編譯參數，它強制指定對齊模數是2。此例子Windows和Linux計算方法有些許不一致。

在Windows中計算步驟如下：
步驟1：所有數據成員自身長度和：1B + 8B = 13B --> sum_a = 9B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是2，之前需填充1個字節，sum_a + 1 = 10B --> sum_b = 10 B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲8後者爲2，所以結構體對齊模數是2。sum_b是2的5倍，不需再次對齊。
綜上3步，可知結構體的長度是10B，各數據成員在內存中的分佈如圖2-1所示。

在Linux中計算步驟如下：
步驟1：所有數據成員自身長度和：1B + 12B = 13B --> sum_a = 13B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是2，之前需填充1個字節，sum_a + 1 = 14B --> sum_b = 14 B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲8後者爲2，所以結構體對齊模數是2。sum_b是2的7倍，不需再次對齊。
綜上3步，可知結構體的長度是14B，各數據成員在內存中的分佈如圖2-2所示。



例子3：

struct my_struct { 
    char a; 
    double b; 
    char c; 
}; 

前兩例中，數據成員在Linux和Windows下都相同，例3中double的對齊模數在Linux中是4，在Windows下是8，針對這種模數不相同的情況加以分析。
在Windows中計算步驟如下：
步驟1：所有數據成員自身長度和：1B + 8B + 1B = 10B --> sum_a = 10B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是8，之前需填充7個字節，sum_a + 7 = 17B --> sum_b = 17B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲8後者爲8，所以結構體對齊模數是8。sum_b應該是8的整數倍，所以要在結構體後填充8*3 - 17 = 7個字節。
綜上3步，可知結構體的長度是24B，各數據成員在內存中的分佈如圖3-1所示。

在Linux中計算步驟如下：
步驟1：所有數據成員自身長度和：1B + 8B + 1B = 10B，sum_a = 10B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是4，之前需填充3個字節，sum_b = sum_a + 3 = 13B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma
pack中較小者，前者爲8後者爲4，所以結構體對齊模數是4。sum_b應該是4的整數倍，所以要在結構體後填充4*4 - 13 = 3個字節。
綜上3步，可知結構體的長度是16B，各數據成員在內存中的分佈如圖3-2所示。



例子4：

struct my_struct { 
    char a[11]; 
    int b; 
    char c; 
}; 

此例子Windows和Linux計算方法一樣，如下：
步驟1：所有數據成員自身長度和：11B + 4B + 1B = 16B --> sum_a = 16B
步驟2：數據成員a放在相對偏移0處，之前不需要填充字節；數據成員b爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是4，之前需填充3個字節，sum_a + 1 = 17B --> sum_b = 17B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲4後者爲4，所以結構體對齊模數是4。sum_b是4的整數倍，需在結構體後填充4*5 - 17 = 1個字節。
綜上3步，可知結構體的長度是20B，各數據成員在內存中的分佈如圖4所示。



例子5：

struct my_test { 
    int my_test_a; 
    char my_test_b; 
}; 
struct my_struct 
{ 
    struct my_test a; 
    double my_struct_a; 
    int my_struct_b; 
    char my_struct_c; 
}; 

例子5和前幾個例子均不同，在此例子中我們要計算struct my_struct的大小，而my_struct中嵌套了一個my_test結構體。這種結構體應該如何計算呢？原則是將my_test在my_struct中先展開，然後再計算，即是展開成如下結構體：

struct my_struct
{
    int my_test_a;
    char my_test_b;
    double my_struct_a;
    int my_struct_b;
    char my_struct_c;
}; 

此例子Windows中的計算方法如下：
步驟1：所有數據成員自身長度和：4B + 1B + 8B + 4B + 1B= 18B --> sum_a = 18B
步驟2：數據成員my_struct_a爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是8，之前需填充3個字節：sum_a + 3 = 21B --> sum_b = 21B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma pack中較小者，前者爲8後者爲8，所以結構體對齊模數是8。sum_b是8的整數倍，需在結構體後填充3*8 - 21 = 3個字節。
綜上3步，可知結構體的長度是24B，各數據成員在內存中的分佈如圖5所示。

此例子Linux中的計算方法如下：
步驟1：所有數據成員自身長度和：4B + 1B + 8B + 4B + 1B= 18B，sum_a = 18B
步驟2：數據成員my_struct_a爲了內存對齊，根據「結構體大小的計算方法和步驟」中第二條原則，其對齊模數是4，之前需填充3個字節，sum_b = sum_a + 3 = 21B
步驟3：按照定義，結構體對齊模數是結構體內部最大數據成員長度和pragma
pack中較小者，前者爲4後者爲4，所以結構體對齊模數是4。sum_b是4的整數倍，需在結構體後填充6*4 - 21 = 3個字節。
綜上3步，可知結構體的長度是24B，各數據成員在內存中的分佈如圖5所示。

上面的例子均在Windows(VC++6.0)和Linux(GCC4.1.0)上測試驗證。下面是測試程序。

#include <iostream>

#include <stdio.h>

using namespace std;

int main()
{
    cout << "sizeof(char)        = " << sizeof(char) << endl;
    cout << "sizeof(short)       = " << sizeof(short) << endl;
    cout << "sizeof(int)         = " << sizeof(int) << endl;
    cout << "sizeof(long)        = " << sizeof(long) << endl;
    cout << "sizeof(float)       = " << sizeof(float) << endl;
    cout << "sizeof(double)      = " << sizeof(double) << endl;
    cout << "sizeof(long long)   = " << sizeof(long long) << endl;
    cout << "sizeof(long double) = " << sizeof(long double) << endl << endl;    

    // 例子1
    {
        struct my_struct 
        { 
            char a; 
            long double b; 
        };
        cout << "exapmle-1: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        struct my_struct data;

        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子2
    {
        #pragma pack(2) 
        struct my_struct 
        { 
            char a; 
            long double b; 
        }; 

        #pragma pack()
        struct my_struct data;

        cout << "exapmle-2: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        printf("my_struct->a: %u\nmy_struct->b: %u\n\n", &data.a, &data.b);
    }

    // 例子3
    {
        struct my_struct 
        { 
            char a; 
            double b; 
            char c; 
        }; 

        struct my_struct data;

        cout << "exapmle-3: sizeof(my_struct) = " << sizeof(my_struct) << endl;

        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data.a, &data.b, &data.c);
    }

    // 例子4
    {
        struct my_struct 
        {  
            char a[11];  
            int b;  
            char c;  
        };

        cout << "example-4: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;

        struct my_struct data;
        printf("my_struct->a: %u\nmy_struct->b: %u\nmy_struct->c: %u\n\n", &data, &data.b, &data.c);
    }

    // 例子5 
    {
        struct my_test 
        { 
            int my_test_a; 
            char my_test_b; 
        }; 

        struct my_struct 
        { 
            struct my_test a; 
            double my_struct_a; 
            int my_struct_b; 
            char my_struct_c; 
        }; 
        cout << "example-5: sizeof(my_struct) = " << sizeof(struct my_struct) << endl;

        struct my_struct data;
        printf("my_struct->my_test_a  : %u\n"
            "my_struct->my_test_b  : %u\n"
            "my_struct->my_struct_a: %u\n"
            "my_struct->my_struct_b: %u\n"
            "my_struct->my_struct_c: %u\n", &data.a.my_test_a, &data.a.my_test_b, 
            &data.my_struct_a, &data.my_struct_b, &data.my_struct_c);
    }

    return 0;
}

執行結果：

sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 8
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 16

exapmle-1: sizeof(my_struct) = 32
my_struct->a: 2163695552
my_struct->b: 2163695568

exapmle-2: sizeof(my_struct) = 18
my_struct->a: 2163695680
my_struct->b: 2163695682

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2163695648
my_struct->b: 2163695656
my_struct->c: 2163695664

example-4: sizeof(my_struct) = 20
my_struct->a: 2163695616
my_struct->b: 2163695628
my_struct->c: 2163695632

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2163695584
my_struct->my_test_b  : 2163695588
my_struct->my_struct_a: 2163695592
my_struct->my_struct_b: 2163695600
my_struct->my_struct_c: 2163695604

sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 3213889904
my_struct->b: 3213889908

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 3213889890
my_struct->b: 3213889892

exapmle-3: sizeof(my_struct) = 16
my_struct->a: 3213889872
my_struct->b: 3213889876
my_struct->c: 3213889884

example-4: sizeof(my_struct) = 20
my_struct->a: 3213889852
my_struct->b: 3213889864
my_struct->c: 3213889868

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 3213889828
my_struct->my_test_b  : 3213889832
my_struct->my_struct_a: 3213889836
my_struct->my_struct_b: 3213889844
my_struct->my_struct_c: 3213889848

sizeof(char)        = 1
sizeof(short)       = 2
sizeof(int)         = 4
sizeof(long)        = 4
sizeof(float)       = 4
sizeof(double)      = 8
sizeof(long long)   = 8
sizeof(long double) = 12

exapmle-1: sizeof(my_struct) = 16
my_struct->a: 2272336
my_struct->b: 2272340

exapmle-2: sizeof(my_struct) = 14
my_struct->a: 2272322
my_struct->b: 2272324

exapmle-3: sizeof(my_struct) = 24
my_struct->a: 2272296
my_struct->b: 2272304
my_struct->c: 2272312

example-4: sizeof(my_struct) = 20
my_struct->a: 2272276
my_struct->b: 2272288
my_struct->c: 2272292

example-5: sizeof(my_struct) = 24
my_struct->my_test_a  : 2272248
my_struct->my_test_b  : 2272252
my_struct->my_struct_a: 2272256
my_struct->my_struct_b: 2272264
my_struct->my_struct_c: 2272268