結構體數據對齊，sizeof詳解

一、字節對齊的規則：

1、一般設置的對齊方式爲1，2，4字節對齊方式。結構的首地址必須是結構內最寬類型的整數倍地址；

2、結構體的每一個成員起始地址必須是自身類型大小的整數倍(需要特別注意的是windows下是這樣的，但在Linux的gcc編譯器下最高爲4字節對齊），否則在前一類型後補0；這裏特別提到的是數組一定要注意，而且在一些編程的技巧中，我們可以使用數組強制字節達到對齊的目的。這在網絡編程中是很常見的。

舉例：比如CHAR型佔用空間爲1字節，則其起始位置必須可被1整除。INT爲4字節，其起始位置必須被4整除，依次類推。（我們假定類或結構體的起始位置爲0位置，其實編譯器是在開闢空間時，會尋找起始位置可被結構內最寬類型整除的地址做爲開始地址，因此我們可以假定其爲0值，因爲這0值可以被任意的類型整除。）

3、結構體的整體大小必須可被對齊值整除，默認4（結構中的類型大小都小於默認的4）。

4、結構體的整體大小必須可被本結構內的最寬類型整除。（其實和上一條是一樣的，但這裏獨立出來，起注意作用。比如結構體裏的有DOUBLE，那麼結構的大小最後必須可被8整除）

注意：GCC不是這樣，就是最高只能被4整除。此爲32位系統，64爲系統也會採用8整除的方式。否則（2、3條），編譯器會在結構的最後添充一定的特定字符來補齊。

struct T
{
char ch;
double d ;
};

此結果強調爲32系統在VC中是16個字節（d的偏移量要被8整除，所以在ch後需要填充7個字節），GCC中爲12個字節（d的偏移量要被4整除，所以在ch後需要填充3個字節）。64位依舊是16個字節

以下內容轉載至http://blog.csdn.net/w616589292/article/details/45531791

1 -- 結構體數據成員對齊的意義

許多實際的計算機系統對基本類型數據在內存中存放的位置有限制，它們會要求這些數據的起始地址的值是某個數k的倍數，這就是所謂的內存對齊，而這個k則被稱爲該數據類型的對齊模數(alignment modulus)。這種強制的要求一來簡化了處理器與內存之間傳輸系統的設計，二來可以提升讀取數據的速度。
比如這麼一種處理器，它每次讀寫內存的時候都從某個8倍數的地址開始，一次讀出或寫入8個字節的數據，假如軟件能保證double類型的數據都從8倍數地址開始，那麼讀或寫一個double類型數據就只需要一次內存操作。否則，我們就可能需要兩次內存操作才能完成這個動作，因爲數據或許恰好橫跨在兩個符合對齊要求的8字節內存塊上。

2 -- 結構體對齊包括兩個方面的含義

1)結構體總長度；
2)結構體內各數據成員的內存對齊，即該數據成員相對結構體的起始位置；

3 -- 結構體大小的計算方法和步驟

1)將結構體內所有數據成員的長度值相加，記爲sum_a；
2)將各數據成員爲了內存對齊，按各自對齊模數而填充的字節數累加到和sum_a上，記爲sum_b。對齊模數是#pragma pack指定的數值以及該數據成員自身長度中數值較小者。該數據相對起始位置應該是對齊模式的整數倍;
3)將和sum_b向結構體模數對齊，該模數是【#pragma pack指定的數值】、【未指定#pragma pack時，系統默認的對齊模數（32位系統爲4字節，64位爲8字節）】和【結構體內部最大的基本數據類型成員】長度中數值較小者。結構體的長度應該是該模數的整數倍。

4 -- 結構體大小計算舉例

在計算之前，我們首先需要明確的是各個數據成員的對齊模數，對齊模數和數據成員本身的長度以及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
Win-32	模數	1	2	4	4	4	8	8	8
Linux-32	長度	1	2	4	4	4	8	8	12
Linux-32	模數	1	2	4	4	4	4	4	4
Linux-64	長度	1	2	4	8	4	8	8	16
Linux-64	模數	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所示。

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;
}

執行結果：

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 28 19:20:26 UTC 2012 (641c197) x86_64 x86_64 x86_64 GNU/Linux
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

//Linux localhost 3.4.6-2.10-desktop #1 SMP PREEMPT Thu Jul 26 09:36:26 UTC 2012 (641c197) i686 i686 i386 GNU/Linux
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

//CYGWIN_NT-6.1 motadou-PC 1.7.20(0.266/5/3) 2013-06-07 11:11 i686 Cygwin
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

結構體數據對齊，sizeof詳解

工作中用到的腳本合集

24-5-18 X

線程中sleep和wait有什麼區別

C語言版的線性迴歸分析函數

C++最小二乘法擬合-（線性擬合和多項式擬合）

【Unity技巧】四元數（Quaternion）和旋轉

cminpack軟件包中lmdif求最小二乘解的函數使用

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結