編譯器為何進行內存對齊

A. 什麼是數據的對齊為什麼要對齊

有關位元組對齊的介紹：

什麼是對齊，以及為什麼要對齊：
現代計算機中內存空間都是按照byte劃分的，從理論上講似乎對任何類型的變數的訪問可以從任何地址開始，但實際情況是在訪問特定變數的時候經常在特定的內存地址訪問，這就需要各類型數據按照一定的規則在空間上排列，而不是順序的一個接一個的排放，這就是對齊。

對齊的作用和原因：各個硬體平台對存儲空間的處理上有很大的不同。一些平台對某些特定類型的數據只能從某些特定地址開始存取。其他平台可能沒有這種情況，但是最常見的是如果不按照適合其平台要求對數據存放進行對齊，會在存取效率上帶來損失。比如有些平台每次讀都是從偶地址開始，如果一個int型（假設為32 位系統）如果存放在偶地址開始的地方，那麼一個讀周期就可以讀出，而如果存放在奇地址開始的地方，就可能會需要2個讀周期，並對兩次讀出的結果的高低位元組進行拼湊才能得到該int數據。顯然在讀取效
率上下降很多。這也是空間和時間的博弈。

對齊的實現
通常，我們寫程序的時候，不需要考慮對齊問題。編譯器會替我們選擇適合目標平台的對齊策略。當然，我們也可以通知給編譯器傳遞預編譯指令而改變對指定數據的對齊方法。
但是，正因為我們一般不需要關心這個問題，所以因為編輯器對數據存放做了對齊，而我們不了解的話，常常會對一些問題感到迷惑。最常見的就是struct數據結構的sizeof結果，出乎意料。為此，我們需要對對齊演算法所了解。

對齊的演算法：

設結構體如下定義：
struct A
{
int a;
char b;
short c;
};
結構體A中包含了4位元組長度的int一個，1位元組長度的char一個和2位元組長度的short型數據一個。所以A用到的空間應該是7位元組。但是因為編譯器要對數據成員在空間上進行對齊。
所以使用sizeof(strcut A)值為8。
現在把該結構體調整成員變數的順序。
struct B
{
char b;
int a;
short c;
};
這時候同樣是總共7個位元組的變數，但是sizeof(struct B)的值卻是12。
下面我們使用預編譯指令#progma pack (value)來告訴編譯器，使用我們指定的對齊值來取代預設的。
#progma pack (2) /*指定按2位元組對齊*/
struct C
{
char b;
int a;
short c;
};
#progma pack () /*取消指定對齊，恢復預設對齊*/
sizeof(struct C)值是8。

修改對齊值為1：
#progma pack (1) /*指定按1位元組對齊*/
struct D
{
char b;
int a;
short c;
};
#progma pack () /*取消指定對齊，恢復預設對齊*/
sizeof(struct D)值為7。

對於char型數據，其自身對齊值為1，對於short型為2，對於int,float,double類型，其自身對齊值為4，單位位元組。
這裡面有四個概念值：
1.數據類型自身的對齊值：就是上面交代的基本數據類型的自身對齊值。
2.指定對齊值：#progma pack (value)時的指定對齊值value。
3.結構體或者類的自身對齊值：其成員中自身對齊值最大的那個值。
4.數據成員、結構體和類的有效對齊值：自身對齊值和指定對齊值中小的那個值。
有了這些值，我們就可以很方便的來討論具體數據結構的成員和其自身的對齊方式。有效對齊值N是最終用來決定數據存放地址方式的值，最重要。有效對齊N，就是表示「對齊在N上」，也就是說該數據的"存放起始地址%N=0".而數據結構中的數據變數都是按定義的先後順序來排放的。第一個數據變數的起始地址就是數據結構的起始地址。結構體的成員變數要對齊排放，結構體本身也要根據自身的有效對齊值圓整(就是結構體成員變數佔用總長度需要是對結構體有效對齊值的整數倍，結合下面例子理解)。這樣就不能理解上面的幾個例子的值了。
例子分析：
分析例子B；
struct B
{
char b;
int a;
short c;
};
假設B從地址空間0x0000開始排放。該例子中沒有定義指定對齊值，在筆者環境下，該值默認為4。第一個成員變數b的自身對齊值是1，比指定或者默認指定對齊值4小，所以其有效對齊值為1，所以其存放地址0x0000符合0x0000%1=0.第二個成員變數a，其自身對齊值為4，所以有效對齊值也為4，所以只能存放在起始地址為0x0004到0x0007這四個連續的位元組空間中，復核0x0004%4=0,且緊靠第一個變數。第三個變數c,自身對齊值為 2，所以有效對齊值也是2，可以存放在0x0008到0x0009這兩個位元組空間中，符合0x0008%2=0。所以從0x0000到0x0009存放的都是B內容。再看數據結構B的自身對齊值為其變數中最大對齊值(這里是b）所以就是4，所以結構體的有效對齊值也是4。根據結構體圓整的要求， 0x0009到0x0000=10位元組，（10＋2）％4＝0。所以0x0000A到0x000B也為結構體B所佔用。故B從0x0000到0x000B 共有12個位元組,sizeof(struct B)=12;

同理,分析上面例子C：
#progma pack (2) /*指定按2位元組對齊*/
struct C
{
char b;
int a;
short c;
};
#progma pack () /*取消指定對齊，恢復預設對齊*/
第一個變數b的自身對齊值為1，指定對齊值為2，所以，其有效對齊值為1，假設C從0x0000開始，那麼b存放在0x0000，符合0x0000%1= 0;第二個變數，自身對齊值為4，指定對齊值為2，所以有效對齊值為2，所以順序存放在0x0002、0x0003、0x0004、0x0005四個連續位元組中，符合0x0002%2=0。第三個變數c的自身對齊值為2，所以有效對齊值為2，順序存放
在0x0006、0x0007中，符合 0x0006%2=0。所以從0x0000到0x00007共八位元組存放的是C的變數。又C的自身對齊值為4，所以C的有效對齊值為2。又8%2=0,C 只佔用0x0000到0x0007的八個位元組。所以sizeof(struct C)=8.

B. 下載程序時位元組對齊

一、快速理解

1、內存對齊原則：

第一個成員的首地址為0.
每個成員的首地址是自身大小的整數倍
結構體的總大小，為其成員中所含最大類型的整數倍。
2、什麼是位元組對齊？

在C語言中，結構是一種復合數據類型，其構成元素既可以是基本數據類型（如int、long、float等）的變數，也可以是一些復合數據類型（如數組、結構、聯合等）的數據單元。在結構中，編譯器為結構的每個成員按其自然邊界（alignment）分配空間。各個成員按照它們被聲明的順序在內存中順序存儲，第一個成員的地址和整個結構的地址相同。
為了使CPU能夠對變數進行快速的訪問,變數的起始地址應該具有某些特性,即所謂的」對齊」.
比如4位元組的int型,其起始地址應該位於4位元組的邊界上,即起始地址能夠被4整除.
3、 位元組對齊有什麼作用？

位元組對齊的作用不僅是便於cpu快速訪問。
同時合理的利用位元組對齊可以有效地節省存儲空間。
對於32位機來說，4位元組對齊能夠使cpu訪問速度提高，比如說一個long類型的變數，如果跨越了4位元組邊界存儲，那麼cpu要讀取兩次，這樣效率就低了。
但是在32位機中使用1位元組或者2位元組對齊，反而會使變數訪問速度降低。所以這要考慮處理器類型，另外還得考慮編譯器的類型。在vc中默認是4位元組對齊的，GNU gcc 是默認4位元組對齊。
4、 更改C編譯器的預設位元組對齊方式

在預設情況下，C編譯器為每一個變數或是數據單元按其自然對界條件分配空間。一般地，可以通過下面的方法來改變預設的對界條件：

使用偽指令#pragma pack (n)，C編譯器將按照n個位元組對齊。
使用偽指令#pragma pack()，取消自定義位元組對齊方式。
另外，還有如下的一種方式：

__attribute((aligned (n)))，讓所作用的結構成員對齊在n位元組自然邊界上。如果結構中有成員的長度大於n，則按照最大成員的長度來對齊。 ·
attribute ((packed))，取消結構在編譯過程中的優化對齊，按照實際佔用位元組數進行對齊。
5、 舉例說明

例1

struct test
{
char x1;
short x2;
float x3;
char x4;
};
1
2
3
4
5
6
7
1
2
3
4
5
6
7
由於編譯器默認情況下會對這個struct作自然邊界（有人說「自然對界」我覺得邊界更順口）對齊，結構的第一個成員x1，其偏移地址為0，占據了第1個位元組。第二個成員x2為short類型，其起始地址必須2位元組對界。
因此，編譯器在x2和x1之間填充了一個空位元組。結構的第三個成員x3和第四個成員x4恰好落在其自然邊界地址上，在它們前面不需要額外的填充位元組。
在test結構中，成員x3要求4位元組對界，是該結構所有成員中要求的最大邊界單元，因而test結構的自然對界條件為4位元組，編譯器在成員x4後面填充了3個空位元組。整個結構所佔據空間為12位元組。

例2

#pragma pack(1) //讓編譯器對這個結構作1位元組對齊
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1位元組對齊，恢復為默認4位元組對齊
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
這時候sizeof(struct test)的值為8。

例3

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
這時候sizeof(struct test)的值仍為8。

二、深入理解

①什麼是位元組對齊,為什麼要對齊?
現代計算機中內存空間都是按照byte劃分的，從理論上講似乎對任何類型的變數的訪問可以從任何地址開始。
但實際情況是在訪問特定類型變數的時候經常在特定的內存地址訪問，這就需要各種類型數據按照一定的規則在空間上排列，而不是順序的一個接一個的排放，這就是對齊。
對齊的作用和原因：各個硬體平台對存儲空間的處理上有很大的不同。一些平台對某些特定類型的數據只能從某些特定地址開始存取。比如有些架構的CPU在訪問一個沒有進行對齊的變數的時候會發生錯誤,那麼在這種架構下編程必須保證位元組對齊.其他平台可能沒有這種情況，但是最常見的是如果不按照適合其平台要求對數據存放進行對齊，會在存取效率上帶來損失。比如有些平台每次讀都是從偶地址開始，如果一個int型（假設為32位系統）如果存放在偶地址開始的地方，那麼一個讀周期就可以讀出這32bit，而如果存放在奇地址開始的地方，就需要2個讀周期，並對兩次讀出的結果的高低位元組進行拼湊才能得到該32bit數據。顯然在讀取效率上下降很多。
②位元組對齊對程序的影響:

先讓我們看幾個例子吧(32bit,x86環境,gcc編譯器):

設結構體如下定義：

struct A
{
int a;
char b;
short c;
};
struct B
{
char b;
int a;
short c;
};
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
現在已知32位機器上各種數據類型的長度如下:
char:1(有符號無符號同)
short:2(有符號無符號同)
int:4(有符號無符號同)
long:4(有符號無符號同)
float:4 double:8
那麼上面兩個結構大小如何呢?
結果是:
sizeof(strcut A)值為8
sizeof(struct B)的值卻是12一、快速理解

1、內存對齊原則：

第一個成員的首地址為0.
每個成員的首地址是自身大小的整數倍
結構體的總大小，為其成員中所含最大類型的整數倍。
2、什麼是位元組對齊？

在C語言中，結構是一種復合數據類型，其構成元素既可以是基本數據類型（如int、long、float等）的變數，也可以是一些復合數據類型（如數組、結構、聯合等）的數據單元。在結構中，編譯器為結構的每個成員按其自然邊界（alignment）分配空間。各個成員按照它們被聲明的順序在內存中順序存儲，第一個成員的地址和整個結構的地址相同。
為了使CPU能夠對變數進行快速的訪問,變數的起始地址應該具有某些特性,即所謂的」對齊」.
比如4位元組的int型,其起始地址應該位於4位元組的邊界上,即起始地址能夠被4整除.
3、 位元組對齊有什麼作用？

位元組對齊的作用不僅是便於cpu快速訪問。
同時合理的利用位元組對齊可以有效地節省存儲空間。
對於32位機來說，4位元組對齊能夠使cpu訪問速度提高，比如說一個long類型的變數，如果跨越了4位元組邊界存儲，那麼cpu要讀取兩次，這樣效率就低了。
但是在32位機中使用1位元組或者2位元組對齊，反而會使變數訪問速度降低。所以這要考慮處理器類型，另外還得考慮編譯器的類型。在vc中默認是4位元組對齊的，GNU gcc 是默認4位元組對齊。
4、 更改C編譯器的預設位元組對齊方式

在預設情況下，C編譯器為每一個變數或是數據單元按其自然對界條件分配空間。一般地，可以通過下面的方法來改變預設的對界條件：

使用偽指令#pragma pack (n)，C編譯器將按照n個位元組對齊。
使用偽指令#pragma pack()，取消自定義位元組對齊方式。
另外，還有如下的一種方式：

__attribute((aligned (n)))，讓所作用的結構成員對齊在n位元組自然邊界上。如果結構中有成員的長度大於n，則按照最大成員的長度來對齊。 ·
attribute ((packed))，取消結構在編譯過程中的優化對齊，按照實際佔用位元組數進行對齊。
5、 舉例說明

例1

struct test
{
char x1;
short x2;
float x3;
char x4;
};
1
2
3
4
5
6
7
1
2
3
4
5
6
7
由於編譯器默認情況下會對這個struct作自然邊界（有人說「自然對界」我覺得邊界更順口）對齊，結構的第一個成員x1，其偏移地址為0，占據了第1個位元組。第二個成員x2為short類型，其起始地址必須2位元組對界。
因此，編譯器在x2和x1之間填充了一個空位元組。結構的第三個成員x3和第四個成員x4恰好落在其自然邊界地址上，在它們前面不需要額外的填充位元組。
在test結構中，成員x3要求4位元組對界，是該結構所有成員中要求的最大邊界單元，因而test結構的自然對界條件為4位元組，編譯器在成員x4後面填充了3個空位元組。整個結構所佔據空間為12位元組。

例2

#pragma pack(1) //讓編譯器對這個結構作1位元組對齊
struct test
{
char x1;
short x2;
float x3;
char x4;
};
#pragma pack() //取消1位元組對齊，恢復為默認4位元組對齊
1
2
3
4
5
6
7
8
9
1
2
3
4
5
6
7
8
9
這時候sizeof(struct test)的值為8。

例3

#define GNUC_PACKED __attribute__((packed))
struct PACKED test
{
char x1;
short x2;
float x3;
char x4;
}GNUC_PACKED;
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8
這時候sizeof(struct test)的值仍為8。

二、深入理解

①什麼是位元組對齊,為什麼要對齊?
現代計算機中內存空間都是按照byte劃分的，從理論上講似乎對任何類型的變數的訪問可以從任何地址開始。
但實際情況是在訪問特定類型變數的時候經常在特定的內存地址訪問，這就需要各種類型數據按照一定的規則在空間上排列，而不是順序的一個接一個的排放，這就是對齊。
對齊的作用和原因：各個硬體平台對存儲空間的處理上有很大的不同。一些平台對某些特定類型的數據只能從某些特定地址開始存取。比如有些架構的CPU在訪問一個沒有進行對齊的變數的時候會發生錯誤,那麼在這種架構下編程必須保證位元組對齊.其他平台可能沒有這種情況，但是最常見的是如果不按照適合其平台要求對數據存放進行對齊，會在存取效率上帶來損失。比如有些平台每次讀都是從偶地址開始，如果一個int型（假設為32位系統）如果存放在偶地址開始的地方，那麼一個讀周期就可以讀出這32bit，而如果存放在奇地址開始的地方，就需要2個讀周期，並對兩次讀出的結果的高低位元組進行拼湊才能得到該32bit數據。顯然在讀取效率上下降很多。
②位元組對齊對程序的影響:

先讓我們看幾個例子吧(32bit,x86環境,gcc編譯器):

設結構體如下定義：

struct A
{
int a;
char b;
short c;
};
struct B
{
char b;
int a;
short c;
};
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12
現在已知32位機器上各種數據類型的長度如下:
char:1(有符號無符號同)
short:2(有符號無符號同)
int:4(有符號無符號同)
long:4(有符號無符號同)
float:4 double:8
那麼上面兩個結構大小如何呢?
結果是:
sizeof(strcut A)值為8
sizeof(struct B)的值卻是12

C. 內存對齊詳解

1、什麼是內存對齊
假設我們聲明兩個變數：

2、結構體內存對齊規則

結構體所佔用的內存與其成員在結構體中的聲明順序有關，其成員的內存對齊規則如下：

（1）每個成員分別按自己的對齊位元組數和PPB（指定的對齊位元組數，32位機默認為4）兩個位元組數最小的那個對齊，這樣可以最小化長度。

（2）復雜類型(如結構)的默認對齊方式是它最長的成員的對齊方式，這樣在成員是復雜類型時，可以最小化長度。

（3）結構體對齊後的長度必須是成員中最大的對齊參數（PPB）的整數倍，這樣在處理數組時可以保證每一項都邊界對齊。

（4）計算結構體的內存大小時，應該列出每個成員的偏移地址，則其長度=最後一個成員的偏移地址+最後一個成員數的長度+最後一個成員的調整參數（考慮PPB）。

3、案例講解：

————————————————
最後輸出的結果為：8

4、注意的問題
（1）位元組對齊取決於編譯器；
（2）一定要注意PPB大小，PPB大小由pragam pack(n)指定；
（3）結構體佔用的位元組數要能夠被PPB整除。
（4）總結出一個公式：結構體的大小等於最後一個成員的偏移量加上其大小再加上末尾的填充位元組數目，即：
sizeof( struct ) = offsetof( last item ) + sizeof( last item ) +sizeof( trailing padding )

————————————————
原文鏈接： https://blog.csdn.net/SzMinglove/java/article/details/8143056

D. 結構體內存對齊

結構體內存對齊

一、結構體對齊的三大原則

1、數據成員對齊規則：結構（struct）(或聯合體(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員存儲的起始位置要從該成員大小或者成員的子成員大小（只要該成員有子成員，比如說是數組、結構體等）的整數倍開始（比如int為4位元組，則要從4的整數倍地址開始存儲）

2、結構體作為成員：如果一個結構體里有某些結構體成員，則結構體成員要從其內部最大元素大小的整數倍地址開始存儲（struct a里存有struct b，b裡面有char、int 、double等元素，那b應該從8的整數倍開始存儲）

3、收尾工作：結構體的總大小，也就是sizeof的結果，必須是其內部最大成員的整數倍，不足的要補齊。

首先，我們看一下各個數據類型在不同操作系統中所佔的位數

二、內存對齊規則的應用

圖中輸出結果是24，為什麼是24呢？

a 為double類型，佔8個位元組，又因為是第一個成員，起始值對應offset為0的位置。又因為佔8個位元組，所以a對應的是偏移量為8的地址空間

b 為char類型，佔1個位元組，對齊到1的整數倍，也就是下一個地址空間。

c 為int類型，佔4個位元組，對齊到4的整數倍，對齊數為12，偏移量為4的地址空間

d 為short類型，佔2個位元組，對齊到2的整數倍，對齊數為16，偏移量為2的地址空間

結構體的總大小，必須是其內部最大成員的整數倍，不足的要補齊，struct1中最大的成員為double類型，那麼結構體的總大小即為8的整數倍，目前已經佔了17位元組，所以總大小應為24個位元組

我們再看一下下面的輸出又是多少呢？

輸出結果是16。

如圖a不變

b 為int類型，佔4個位元組，對齊到4的整數倍，對齊數為8，偏移量為4的地址空間

c 為char類型，佔1個位元組，對齊到1的整數倍，也就是下一個地址空間。

d 為short類型，佔2個位元組，對齊到2的整數倍，對齊數為14，偏移量為2的地址空間

又因為內存對齊原則，所以結構體的總大小為16個位元組

那麼結構體是否可以嵌套使用呢，嵌套使用的話，內存又該如何計算呢？

這里的輸出結果是多少呢。我們來計算一下

如圖a不變

b 為int類型，佔4個位元組，對齊到4的整數倍，對齊數為8，偏移量為4的地址空間

c 為char類型，佔1個位元組，對齊到1的整數倍，也就是下一個地址空間。

d 為short類型，佔2個位元組，對齊到2的整數倍，對齊數為14，偏移量為2的地址空間

e 為int類型，佔4個位元組，對齊到4的整數倍，對齊數為16，偏移量為4的地址空間

已知struct1佔24個位元組，double 佔8個位元組，不知道為什麼的請往上看。

結構體作為成員：如果一個結構體里有某些結構體成員，則結構體成員要從其內部最大元素大小的整數倍地址開始存儲（struct a里存有struct b，b裡面有char、int 、double等元素，那b應該從8的整數倍開始存儲）

所以struct1 應該從8的整數倍開始存儲

那麼struct1 佔24個位元組，對齊到8的整數倍，對齊數為24，偏移量為24的地址空間

所以結構體的總大小為48個位元組

三、為什麼要內存對齊呢？

（一）性能上的提升

從內存佔用的角度講，對齊後比未對齊有些情況反而增加了內存分配的開支，是為了什麼呢？

數據結構(尤其是棧)應該盡可能地在自然邊界上對齊，為了訪問未對齊的內存，處理器需要作兩次內存訪問；而對齊的內存訪問僅需要一次訪問。最重要的是提高內存系統的性能。

（二）跨平台

有些硬體平台並不能訪問任意地址上的任意數據的，只能處理特定類型的數據，否則會導致硬體層級的錯誤。

有些CPU（如基於 Alpha，IA-64，MIPS，和 SuperH 體系的）拒絕讀取未對齊數據。當一個程序要求這些 CPU 讀取未對齊數據時，這時 CPU 會進入異常處理狀態並且通知程序不能繼續執行。

舉個例子，在 ARM，MIPS，和 SH 硬體平台上，當操作系統被要求存取一個未對齊數據時會默認給應用程序拋出硬體異常。所以，如果編譯器不進行內存對齊，那在很多平台的上的開發將難以進行。

E. 內存對齊的規則

為了加快計算機的取數速度，編譯器默認對內存進行位元組對齊。對結構體（包括類）進行位元組對齊的原則是：
1）結構體變數的首地址能夠被其最寬基本類型成員的大小所整除；
2）結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal adding）；
3）結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之後加上填充位元組（trailing padding）。

struct SByte1
{
double d; // 偏移量0~7
char j; // 偏移量8
int a; // 偏移量12~15，由於9不能整除4，故先填充9~11
};
sizeof(SByte1); // = 16

struct SByte2
{
char j; // 偏移量0
double d; // 偏移量8~15，由於1不能整除8，故先填充1~7
int a; // 偏移量16~19
};
sizeof(SByte2); // = 24，為了湊成8的倍數，填充20~23

F. C語言內存對齊問題.

為了有助於加快計算機的取數速度，編譯器默認會對結構體進行處理（實際上其它地方的數據變數也是如此），讓寬度為2的基本數據類型（short等）都位於能被2整除的地址上，讓寬度為4的基數據類型（int等）都位於能被4整除的地址上，以此類推。這樣，兩個數中間就可能需要加入填充位元組，所以整個結構體的sizeof值就增長了。

位元組對齊的細節和編譯器實現相關，但一般而言，滿足三個准則：
1) 結構體變數的首地址能夠被其最寬基本類型成員的大小所整除；
2) 結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有
需要編譯器會在成員之間加上填充位元組（internal adding）；
3) 結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一
個成員之後加上填充位元組（trailing padding）。

你這里struct的首地址要能被double的8位元組整除，

1. char佔1位元組

2. int要被此時的地址整除，那麼需要補上3位元組，所以這里一共該是8位元組

3. short2位元組的，一共10位元組，不滿足3），不能整除int，故添加2位元組

4. 最後是double 8位元組，這里地址應該是首地址+12不能被8整除，所以+4位元組。最後一共24B！

   問題解決求採納！

G. c#中內存對齊是怎麼回事

有虛函數的話就有虛表，虛表保存虛函數地址，一個地址佔用的長度根據編譯器不同有可能不同，vs裡面是8個位元組，在devc++裡面是4個位元組。類和結構體的對齊方式相同，有兩條規則1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行下面是我收集的關於內存對齊的一篇很好的文章：在最近的項目中，我們涉及到了「內存對齊」技術。對於大部分程序員來說，「內存對齊」對他們來說都應該是「透明的」。「內存對齊」應該是編譯器的 「管轄范圍」。編譯器為程序中的每個「數據單元」安排在適當的位置上。但是C語言的一個特點就是太靈活，太強大，它允許你干預「內存對齊」。如果你想了解更加底層的秘密，「內存對齊」對你就不應該再透明了。一、內存對齊的原因大部分的參考資料都是如是說的：1、平台原因(移植原因)：不是所有的硬體平台都能訪問任意地址上的任意數據的；某些硬體平台只能在某些地址處取某些特定類型的數據，否則拋出硬體異常。2、性能原因：數據結構(尤其是棧)應該盡可能地在自然邊界上對齊。原因在於，為了訪問未對齊的內存，處理器需要作兩次內存訪問；而對齊的內存訪問僅需要一次訪問。二、對齊規則每個特定平台上的編譯器都有自己的默認「對齊系數」(也叫對齊模數)。程序員可以通過預編譯命令#pragma pack(n)，n=1,2,4,8,16來改變這一系數，其中的n就是你要指定的「對齊系數」。規則：1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行。3、結合1、2顆推斷：當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果。三、試驗我們通過一系列例子的詳細說明來證明這個規則吧!我試驗用的編譯器包括GCC 3.4.2和VC6.0的C編譯器，平台為Windows XP + Sp2。我們將用典型的struct對齊來說明。首先我們定義一個struct：#pragma pack(n) /* n = 1, 2, 4, 8, 16 */struct test_t { int a; char b; short c; char d;};#pragma pack(n)首先我們首先確認在試驗平台上的各個類型的size，經驗證兩個編譯器的輸出均為：sizeof(char) = 1sizeof(short) = 2sizeof(int) = 4我們的試驗過程如下：通過#pragma pack(n)改變「對齊系數」，然後察看sizeof(struct test_t)的值。1、1位元組對齊(#pragma pack(1))輸出結果：sizeof(struct test_t) = 8 [兩個編譯器輸出一致]分析過程：1) 成員數據對齊#pragma pack(1)struct test_t { int a; /* 長度4 < 1 按1對齊；起始offset=0 0%1=0；存放位置區間[0,3] */ char b; /* 長度1 = 1 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */ short c; /* 長度2 > 1 按1對齊；起始offset=5 5%1=0；存放位置區間[5,6] */ char d; /* 長度1 = 1 按1對齊；起始offset=7 7%1=0；存放位置區間[7] */};#pragma pack()成員總大小=82) 整體對齊整體對齊系數 = min((max(int,short,char), 1) = 1整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 8 /* 8%1=0 */ [注1]2、2位元組對齊(#pragma pack(2))輸出結果：sizeof(struct test_t) = 10 [兩個編譯器輸出一致]分析過程：1) 成員數據對齊#pragma pack(2)struct test_t { int a; /* 長度4 > 2 按2對齊；起始offset=0 0%2=0；存放位置區間[0,3] */ char b; /* 長度1 < 2 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */ short c; /* 長度2 = 2 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */ char d; /* 長度1 < 2 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */};#pragma pack()成員總大小=92) 整體對齊整體對齊系數 = min((max(int,short,char), 2) = 2整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 10 /* 10%2=0 */3、4位元組對齊(#pragma pack(4))輸出結果：sizeof(struct test_t) = 12 [兩個編譯器輸出一致]分析過程：1) 成員數據對齊#pragma pack(4)struct test_t { int a; /* 長度4 = 4 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */ char b; /* 長度1 < 4 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */ short c; /* 長度2 < 4 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */ char d; /* 長度1 < 4 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */};#pragma pack()成員總大小=92) 整體對齊整體對齊系數 = min((max(int,short,char), 4) = 4整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 12 /* 12%4=0 */4、8位元組對齊(#pragma pack(8))輸出結果：sizeof(struct test_t) = 12 [兩個編譯器輸出一致]分析過程：1) 成員數據對齊#pragma pack(8)struct test_t { int a; /* 長度4 < 8 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */ char b; /* 長度1 < 8 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */ short c; /* 長度2 < 8 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */ char d; /* 長度1 < 8 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */};#pragma pack()成員總大小=92) 整體對齊整體對齊系數 = min((max(int,short,char), 8) = 4整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 12 /* 12%4=0 */5、16位元組對齊(#pragma pack(16))輸出結果：sizeof(struct test_t) = 12 [兩個編譯器輸出一致]分析過程：1) 成員數據對齊#pragma pack(16)struct test_t { int a; /* 長度4 < 16 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */ char b; /* 長度1 < 16 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */ short c; /* 長度2 < 16 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */ char d; /* 長度1 < 16 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */};#pragma pack()成員總大小=92) 整體對齊整體對齊系數 = min((max(int,short,char), 16) = 4整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 12 /* 12%4=0 */四、結論8位元組和16位元組對齊試驗證明了「規則」的第3點：「當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果」。另外內存對齊是個很復雜的東西，上面所說的在有些時候也可能不正確。呵呵^_^[注1]什麼是「圓整」？舉例說明：如上面的8位元組對齊中的「整體對齊」，整體大小=9 按 4 圓整 = 12圓整的過程：從9開始每次加一，看是否能被4整除，這里9，10，11均不能被4整除，到12時可以，則圓整結束。

H. 內存對齊的詳細解釋

大部分的參考資料都是如是說的：
1、平台原因(移植原因)：不是所有的硬體平台都能訪問任意地址上的任意數據的；某些硬體平台只能在某些地址處取某些特定類型的數據，否則拋出硬體異常。
2、性能原因：數據結構(尤其是棧)應該盡可能地在自然邊界上對齊。原因在於，為了訪問未對齊的內存，處理器需要作兩次內存訪問；而對齊的內存訪問僅需要一次訪問。 每個特定平台上的編譯器都有自己的默認「對齊系數」(也叫對齊模數)。程序員可以通過預編譯命令#pragma pack(n)，n=1,2,4,8,16來改變這一系數，其中的n就是你要指定的「對齊系數」。
規則：
1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。
2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行。
3、結合1、2可推斷：當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果。
Win32平台下的微軟C編譯器(cl.exefor 80×86)的對齊策略：
1)結構體變數的首地址是其最長基本類型成員的整數倍；
備註：編譯器在給結構體開辟空間時，首先找到結構體中最寬的基本數據類型，然後尋找內存地址能是該基本數據類型的整倍的位置，作為結構體的首地址。將這個最寬的基本數據類型的大小作為上面介紹的對齊模數。
2)結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal adding）；
備注:為結構體的一個成員開辟空間之前，編譯器首先檢查預開辟空間的首地址相對於結構體首地址的偏移是否是本成員的整數倍，若是，則存放本成員，反之，則在本成員和上一個成員之間填充一定的位元組，以達到整數倍的要求，也就是將預開辟空間的首地址後移幾個位元組。
3)結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要，編譯器會在最末一個成員之後加上填充位元組（trailing padding）。
備註：結構體總大小是包括填充位元組，最後一個成員滿足上面兩條以外，還必須滿足第三條，否則就必須在最後填充幾個位元組以達到本條要求。
4) 結構體內類型相同的連續元素將在連續的空間內，和數組一樣。
5) 如果結構體內存在長度大於處理器位數的元素，那麼就以處理器的倍數為對齊單位；否則，如果結構體內的元素的長度都小於處理器的倍數的時候，便以結構體裡面最長的數據元素為對齊單位。 我們通過一系列例子的詳細說明來證明這個規則吧!
我試驗用的編譯器包括GCC 3.4.2和VC6.0的C編譯器，平台為Windows XP + Sp2。
我們將用典型的struct對齊來說明。首先我們定義一個struct：
#pragma pack(n) /* n = 1, 2, 4, 8, 16 */
struct test_t {
int a;
char b;
short c;
char d[6];
};
#pragma pack(n)
首先我們首先確認在試驗平台上的各個類型的size，經驗證兩個編譯器的輸出均為：
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
我們的試驗過程如下：通過#pragma pack(n)改變「對齊系數」，然後察看sizeof(struct test_t)的值。
1、1位元組對齊(#pragma pack(1))
輸出結果：sizeof(struct test_t) = 13[兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(1)
struct test_t {
int a; /* int型，長度4 > 1 按1對齊；起始offset=0 0%1=0；存放位置區間[0,3] */
char b; /* char型，長度1 = 1 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 > 1 按1對齊；起始offset=5 5%1=0；存放位置區間[5,6] */
char d[6]; /* char型，長度1 = 1 按1對齊；起始offset=7 7%1=0；存放位置區間[7,C] */
};/*char d[6]要看成6個char型變數*/
#pragma pack()
成員總大小=13
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 1) = 1
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 13 /*13%1=0*/ [注1]
2、2位元組對齊(#pragma pack(2))
輸出結果：sizeof(struct test_t) = 14 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(2)
struct test_t {
int a; /* int型，長度4 > 2 按2對齊；起始offset=0 0%2=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 2 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 = 2 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 2 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 2) = 2
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 14 /* 14%2=0 */
3、4位元組對齊(#pragma pack(4))
輸出結果：sizeof(struct test_t) = 16 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(4)
struct test_t {
int a; /* int型，長度4 = 4 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 4 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /*short型， 長度2 < 4 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 4 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 4) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 16 /*16%4=0*/
4、8位元組對齊(#pragma pack(8))
輸出結果：sizeof(struct test_t) = 16 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(8)
struct test_t {
int a; /* int型，長度4 < 8 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 8 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 < 8 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 8 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 8) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 16 /*16%4=0*/
5、16位元組對齊(#pragma pack(16))
輸出結果：sizeof(struct test_t) = 16 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(16)
struct test_t {
int a; /* int型，長度4 < 16 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 16 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 < 16 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 16 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 16) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 16 /*16%4=0*/ 8位元組和16位元組對齊試驗證明了「規則」的第3點：「當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果」。另外內存對齊是個很復雜的東西，讀者不妨把上述結構體中加個double型成員進去練習一下，上面所說的在有些時候也可能不正確。呵呵^_^
[注1]
什麼是「圓整」？
舉例說明：如上面的8位元組對齊中的「整體對齊」，整體大小=9 按 4 圓整 = 12
圓整的過程：從9開始每次加一，看是否能被4整除，這里9，10，11均不能被4整除，到12時可以，則圓整結束。
上面文字表述太不直觀了，鄙人給段代碼直觀的體現出來，代碼如下：
#pragma pack(4) /* n = 1, 2, 4, 8, 16 */struct test_t{int a;char b;short c;char d[6];}ttt;void print_hex_data(char *info, char *data, int len){int i;dbg_printf(%s: , info);for(i = 0; i < len; i++){dbg_printf(%02x , (unsigned char)data[i]);if (0 == ((i+1) % 32))dbg_printf( );}dbg_printf( );}int main(){ttt.a = 0x1a2a3a4a;ttt.b = 0x1b;ttt.c = 0x1c2c;char *s = 123456;memcpy(ttt.d, s, 6);print_hex_data(struct_data, (char *)&ttt, sizeof(struct test_t));return 0;}
#pragma pack(1)的結果：
4a 3a 2a 1a 1b 2c 1c 31 32 33 34 35 36
#pragma pack(2)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36
#pragma pack(4)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00
#pragma pack(8)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00
#pragma pack(16)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00