結構體存在記憶體對齊，類(物件)也如此，甚至於所有變數在記憶體中的儲存也有對齊一說(只是這些對程式設計師是透明的，不需要關心)。實際上，這種對齊是為了在空間與複雜度上達到平衡的一種技術手段，簡單的講，是為了在可接受的空間浪費的前提下，儘可能的提高對相同運算過程的最少(快)處理。先舉個例子：

    假設機器字長是32位的(即4位元組，下面示例均按此字長)，也就是說處理任何記憶體中的資料，其實都是按32位的單位進行的。現在有2個變數：    

1. char A; 
2. int B; 

     假設這2個變數是從記憶體地址0開始分配的，如果不考慮對齊，應該是這樣儲存的(見下圖,以intel上的little endian為例，為了形象，每16個位元組分做一行，後同)：

    因為計算機的字長是4位元組的，所以在處理變數A與B時的過程可能大致為：

    A:將0x00-0x03共32位讀入暫存器，再通過左移24位再右移24位運算得到a的值(或與0x000000FF做與運算)

    B:將0x00-0x03這32位讀入暫存器，通過位運算得到低24位的值；再將0x04-0x07這32位讀入暫存器，通過位運算得到高8位的值；再與最先得到的24位做位運算，才可得到整個32位的值。

    上面敘述可知，對a的處理是最簡處理，可對b的處理，本身是個32位數，處理的時候卻得折成2部分，之後再合併，效率上就有些低了。

    想解決這個問題，就需要付出幾個位元組浪費的代價，改為下圖的分配方式：

    按上面的分配方式，A的處理過程不變；B卻簡單得多了：只需將0x04-0x07這32位讀入暫存器就OK了。

    我們可以具體談結構體或類成員的對齊了：

    結構體在編譯成機器程式碼後，其實就沒有本身的集合概念了，而類，實際上是個加強版的結構體，類的物件在例項化時，記憶體中申請的就是一些變數的空間集合(類似於結構體，同時也不包含函式指標)。這些集合中的每個變數，在使用中，都需要涉及上述的加工原則，自然也就需要在效率與空間之間做出權衡。

    為了便捷加工連續多個相同型別原始變數，同時簡化原始變數定址，再彙總上述最少處理原則，通常可以將原始變數的長度做為針對此變數的分配單位，比如記憶體可用64個單元，如果某原始變數長度為8位元組，即使機器字長為4位元組，分配的時候也以8位元組對齊(看似IO次數是相同的)，這樣，定址、分配時，均可以按每8位元組為單位進行，簡化了操作，也可以更高效。

    系統預設的對齊規則，追求的至少兩點：1、變數的最高效加工 2、達到目的1的最少空間 

    舉個例子，一個結構體如下：  

1. //by www.datahf.net zhangyu
2. typedef struct T
3. { 
4.     char c; //本身長度1位元組 
5.     __int64 d;  //本身長度8位元組
6.     int e;  //本身長度4位元組
7.     short f;  //本身長度2位元組
8.     char g;  //本身長度1位元組
9. short h;  //本身長度2位元組
10. }; 

    假設定義了一個結構體變數C，在記憶體中分配到了0x00的位置，顯然：

    對於成員C.c  無論如何，也是一次暫存器讀入，所以先佔一個位元組。

    對於成員C.d  是個64位的變數，如果緊跟著C.c儲存，則讀入暫存器至少需要3次，為了實現最少的2次讀入，至少需要以4位元組對齊；同時對於8位元組的原始變數，為了在定址單位上統一，則需要按8位元組對齊，所以，應該分配到0x08-0xF的位置。

    對於成員C.e  是個32位的變數，自然只需滿足分配起始為整數個32位即可，所以分配至0x10-0x13。

    對於成員C.f  是個16位的變數，直接分配在0x14-0x16上，這樣，反正只需一次讀入暫存器後加工，邊界也與16位對齊。

    對於成員C.g  是個8位的變數，本身也得一次讀入暫存器後加工，同時對於1個位元組的變數，儲存在任何位元組開始都是對齊，所以，分配到0x17的位置。

    對於成員C.h  是個16位的變數，為了保證與16位邊界對齊，所以，分配到0x18-0x1A的位置。

    分配圖如下(還不正確，耐心讀下去)：

    結構體C的佔用空間到h結束就可以了嗎?我們找個示例：如果定義一個結構體陣列 CA[2]，按變數分配的原則，這2個結構體應該是在記憶體中連續儲存的，分配應該如下圖：  

    分析一下上圖，明顯可知，CA[1]的很多成員都不再對齊了，究其原因，是結構體的開始邊界不對齊。

    那結構體的開始偏移滿足什麼條件才可以使其成員全部對齊呢。想一想就明白了：很簡單，保證結構體長度是原始成員最長分配的整數倍即可。     上述結構體應該按最長的.d成員對齊，即與8位元組對齊，這樣正確的分配圖如下：

    當然結構體T的長度:sizeof(T)==0x20;

     再舉個例子，看看在預設對齊規則下，各結構體成員的對齊規則：  

1. //by www.datahf.net zhangyu
2. typedef struct A 
3. { 
4.     char c;  //1個位元組
5.     int d;  //4個位元組，要與4位元組對齊，所以分配至第4個位元組處
6.     short e;  //2個位元組， 上述兩個成員過後，本身就是與2對齊的，所以之前無填充
7.  }; //整個結構體，最長的成員為4個位元組，需要總長度與4位元組對齊，所以， sizeof(A)==12 
8. typedef struct B 
9. { 
10.     char c;  //1個位元組
11.     __int64 d;  //8個位元組，位置要與8位元組對齊，所以分配到第8個位元組處
12.     int e;  //4個位元組，成員d結束於15位元組，緊跟的16位元組對齊於4位元組，所以分配到16-19
13.     short f;  //2個位元組，成員e結束於19位元組，緊跟的20位元組對齊於2位元組，所以分配到20-21
14.     A g;  //結構體長為12位元組，最長成員為4位元組，需按4位元組對齊，所以前面跳過2個位元組,
15. //到24-35位元組處
16.     char h;  //1個位元組，分配到36位元組處
17.     int i;  //4個位元組，要對齊4位元組，跳過3位元組，分配到40-43 位元組
18. }; //整個結構體的最大分配成員為8位元組，所以結構體後面加5位元組填充，被到48位元組。故：
19. //sizeof(B)==48;

    具體的分配圖如下：

 上述全部測試程式碼如下：

1. //by www.datahf.net zhangyu
2. #include "stdio.h" 
3. typedef struct A 
4. { 
5.     char c; 
6.     int d; 
7.     short e; 
8. }; 
9. typedef struct B 
10. { 
11.     char c; 
12.     __int64 d; 
13.     int e; 
14.     short f; 
15.     A g; 
16.     char h; 
17.     int i; 
18. }; 
19. typedef struct C 
20. { 
21.     char c; 
22.     __int64 d; 
23.     int e; 
24.     short f; 
25.     char g; 
26.     short h; 
27. }; 
28. typedef struct D 
29. { 
30.     char a; 
31.     short b; 
32.     char c; 
33. }; 
34. int main() 
35. { 
36.     B *b=new B; 
37.     void *s[32]; 
38.     s[0]=b; 
39.     s[1]=&b->c; 
40.     s[2]=&b->d; 
41.     s[3]=&b->e; 
42.     s[4]=&b->f; 
43.     s[5]=&b->g; 
44.     s[6]=&b->h; 
45.     s[7]=&b->g.c; 
46.     s[8]=&b->g.d; 
47.     s[9]=&b->g.e; 
48.     s[10]=&b->i; 
49.     b->c= 0x11; 
50.     b->d= 0x2222222222222222; 
51.     b->e= 0x33333333; 
52.     b->f=0x4444; 
53.     b->g.c=0x50; 
54.     b->g.d=0x51515151; 
55.     b->g.e=0x5252; 
56.     b->h=0x66; 
57.     int i1=sizeof(A); 
58.     int i2=sizeof(B); 
59.     int i3=sizeof(C); 
60.     int i4=sizeof(D); 
61.     printf("i1:%d\ni2:%d\ni3:%d\ni4:%d\n",i1,i2,i3,i4);//12 48 32 6 
62. } 

執行時的記憶體情況如下圖：

最後，簡單加工一下轉載過來的記憶體對齊正式原則：

  先介紹四個概念：

1)資料型別自身的對齊值：基本資料型別的自身對齊值，等於sizeof(基本資料型別)。

2)指定對齊值：#pragma pack (value)時的指定對齊值value。

3)結構體或者類的自身對齊值：其成員中自身對齊值最大的那個值。

4)資料成員、結構體和類的有效對齊值：自身對齊值和指定對齊值中較小的那個值。

  有效對齊值N是最終用來決定資料存放地址方式的值，最重要。有效對齊N，就是表示“對齊在N上”，也就是說該資料的"存放起始地址%N=0".而資料結構中的資料變數都是按定義的先後順序來排放的。第一個資料變數的起始地址就是 資料結構的起始地址。結構體的成員變數要對齊排放，結構體本身也要根據自身的有效對齊值圓整(就是結構體成員變數佔用總長度需要是對結構體有效對齊值的整 數倍)

#pragma pack (value)來告訴編譯器，使用我們指定的對齊值來取代預設的。

如#pragma pack (1)  /*指定按2位元組對齊*/

#pragma pack () /*取消指定對齊，恢復預設對齊*/