有如下的結構體的定義：

struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
    short e;
};

問題解析： 當記憶體中的值合理對其的時候， 很多機器能夠高效的訪問。 例如， 按位元組定址的32位機器中， 有兩個位元組的short型變數必須放在偶數地址上， 而4位元組的int型變數， 必須放在4的整數倍地址上。 某些機器甚至根本不能訪問沒有對齊的地址。 所以必須要求所有的資料正確的對齊。 

為了解決上述問題， 我們要知道， 32位機器， 對於指標變數， 無論是char型還是int型， 指標變數存的都是地址， 都佔用4bytes。

下面我們一步一步分析：

struct aa{
    char a;
};

|

struct aa{
    char a;
    int b;
};

truct aa{
    char a;
    int b;
    float c;
};

| - - -  | | | |   | | | | 

struct aa{
    char a;
    int b;
    float c;
    double d;
};

 上述佔用12 + 8個位元組。 但是double要求地址offset從8的整數倍開始， 所以填充4個位元組， 變成16， 變成8的倍數， 在存下double。 是 12 + 4  + 8 = 24 bytes:

(char)| - - - (int) | | | |  (float)| | | | - - - -   (double)| | | | | | | |

下面：

struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
};
 

(char)| - - - (int) | | | |  (float)| | | | - - - -   (double)| | | | | | | | (char*) | | | |  - - - - 

struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
};

(char)| - - - (int) | | | |  (float)| | | | - - - -   (double)| | | | | | | | (char*) | | | |  (int*) | | | |

struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
    short e;
};

(char)| - - - (int) | | | |  (float)| | | | - - - -   (double)| | | | | | | | (char*) | | | |  (int*) | | | | (short) | | - -  - - - -

也就是最後尾部還剩下6個bytes空著了。 試想

struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
    short e;
    int f;
};

(char)| - - - (int) | | | |  (float)| | | | - - - -   (double)| | | | | | | | (char*) | | | |  (int*) | | | | (short) | | - -  (int) | | | |

接下來， 如果再加一個short， 就變成了48了， 當然是啦：

struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
    short e;
    int f;
    short g;
};

編譯器可能提供用於控制結構體的這種填充。 例如#pragma， 這樣我們就可以遮蔽掉變數的對齊方式， 自己設定變數的對齊方式。 

例如編譯器提供#pragma pack(n) 來設定變數以n位元組對齊的方式。 n 位元組的對齊方式指的是， 如果n 大於該變數所佔的位元組數， 那麼偏移量必須滿足預設的對齊方式， 如果n 小於變數型別所佔的位元組數， 那麼偏移量必須為n的倍數。 

舉例子如下：

#include <iostream>

using namespace std;

#pragma pack(push) // 保持對齊方式
#pragma pack(4) // 設定4位元組對齊
struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
    short e;
};
#pragma pack(pop) // 恢復對齊方式

int main() {

    cout << sizeof(aa) << endl;

    return 0;
}

分析如下：

4 + 4 + 4 + 8 + 4 + 4 + 4 = 32.

如果我們設定1位元組對齊：

#include <iostream>

using namespace std;

#pragma pack(push) // 保持對齊方式
#pragma pack(1) // 設定1位元組對齊
struct aa{
    char a;
    int b;
    float c;
    double d;
    char* pa;
    int* pb;
    short e;
};
#pragma pack(pop) // 恢復對齊方式

int main() {

    cout << sizeof(aa) << endl;

    return 0;
}

分析：

 1 + 4 + 4 + 8 + 4 + 4 + 2 = 27. 

okay。 完美解決。 

為了理解pack， 給出如下例子：

#include <iostream>

using namespace std;

#pragma pack(push, 1) // 可以合併在一起寫
struct Name{
    bool a;
    double c;
};
#pragma pack(pop)
int main() {
    cout << sizeof(Name);
    return 0;
}

#include <iostream>

using namespace std;

#pragma pack(push, 4)
struct Name{
    bool a;
    double c;
};
#pragma pack(pop)
int main() {
    cout << sizeof(Name);
    return 0;
}

改為：

#include <iostream>

using namespace std;

#pragma pack(push, 8)
struct Name{
    bool a;
    double c;
};
#pragma pack(pop)
int main() {
    cout << sizeof(Name);
    return 0;
}

執行

再比如下面：

#include <iostream>

using namespace std;

#pragma pack(8)
struct aa {
    uint8_t a;
    uint16_t b;
    uint32_t c;

};
#pragma pack()
int main() {
    cout << sizeof(aa) << endl;
}

佔8個位元組：

|- || ||||

再比如:

<pre class="cpp" name="code">#pragma pack(8)
struct aa {
    uint8_t a;
    uint8_t a2;
    uint16_t b;
    uint32_t c;

};
#pragma pack()

在比如：

#pragma pack(8)
struct aa {
    uint8_t a;
    uint16_t b;
    uint32_t c;
    uint8_t a2;

};
#pragma pack()

上述佔12個位元組。 按照預設的對齊方式。