內存對齊的問題主要存在於理解struct等複合結構在內存中的存儲結構。
在C語言中，結構是一種複合數據類型，其構成元素既可以是基本數據類型（如int、long、float等）的變量，也可以是一些複合數據類型（如數組、結構、聯合等）的數據單元。在結構中，編譯器爲結構的每個成員按其自然對界（alignment）條件分配空間。各個成員按照它們被聲明的順序在內存中順序存儲，但不一定是相鄰存儲，第一個成員的地址和整個結構的地址相同。
由此引出內存對齊的概念：許多實際的計算機系統對基本類型數據在內存中存放的位置有限制，它們會要求這些數據的首地址的值是某個對其參數k(通常它爲4或8)的倍數，這就是所謂的內存對齊。
引入內存對齊的原因一方面在於硬件取指的方便，例如在32位總線系統上，如果一個int變量（4字節）放在一個4的倍數開始的內存地址中，則CPU可以一次將其數值讀出，否則的話就要分兩次才能讀出。另一個重要的原因在於移植性的要求，也就是說不是所有的硬件平臺都能訪問任意地址上的任意數據的，某些硬件平臺只能在某些地址處取某些特定類型的數據，否則拋出硬件異常。引入內存對齊的目的主要是爲了可移植性以及最大限度提升硬件性能。
2. 內存對齊規則
內存對齊與平臺，編譯器都有一定的關係，比較流行的關於內存對齊的規則是這樣來描述的：
1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset爲0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。
2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行。
3、結合1、2兩項推斷：當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果。
但是，這種流行的說法並不完善。比如在Linux環境中，gcc對於預編譯指令#pragma pack （N）有一定的限制，不允許N超過gcc的默認值；此外，可以使用__attribute（（aligned（n）））來強制定義某個數據成員或者整個結構的對齊規則，但是這種定義同樣受到系統默認值以及#pragma pack （N）預編譯指令的限制。另外，如果結構成員仍是結構，則上述的第二條就不正確了。最後，上述的說法沒有對結構的內存對齊規則以及由此產生的對佔用存儲空間大小的影響作出說明。
參照流行的關於內存對齊規則的描述，以及在Linux系統中實際的程序測試結果，總結了如下四條內存對齊規則。在規則描述中使用了內存對齊參數的概念（有的文獻中稱其爲對齊模數），其意爲，如果某結構成員的內存對齊參數爲n，則該結構成員一定在該參數整倍數的地址單元處開始。
1. 結構體成員在內存中的起始位置爲該成員內存對齊參數的整數倍(前一字段的末尾和該字段之間可能需要補空位)；
2. 結構體成員的變量對齊參數可由__attribute（（aligned（n）））強制定義，強制定義失敗的情況下，爲全局內存對齊參數（由#define pack (N)指定或使用默認值）和該成員所佔空間大小之間較小的一個。如果該成員也是結構體，請參照3；
3. 整個結構的內存對齊參數同樣可由__attribute（（aligned（n）））強制定義，強制定義失敗的情況下，取該結構中所有成員內存對齊參數中最大的；
4. 結構佔有存儲空間的大小必須爲該結構內存對齊參數的整數倍（可能會在最後補相應數目的空位）；
5. 以上規則是結合流行的關於內存對齊的規則描述基於Linux系統和gcc編譯環境總結的，沒有在Windows環境進行過驗證，但是兩者之間不會有大的差異。
3. 設置內存對齊參數規則
設置內存對齊參數包含兩方面的意思：通過預編譯指令#pragma pack (N)進行全局內存對齊參數設置；通過__attribute（（aligned（n）））強制定義某個結構成員的內存對齊參數。
根據網上查找材料分析，並結合在Linux環境下程序實際測試的結果，總結設置內存對齊參數的規則如下：
1. 可通過#pragma pack （N）設置全局內存對齊參數。但在Linux，gcc編譯環境下，N的值超過默認值4之後將不能生效，gcc將忽略該預編譯指令（Windows中的限制尚不瞭解）。也就是說，在Linux，gcc編譯環境下只能將這個數值降低，不能提高。另外，N必須是2的非負整數次冪。
2. 可通過__attribute（（aligned（n）））強制定義結構成員或者整個結構的內存對齊參數，n也必須是2的非負整數次冪。但是，這裏有兩個限制：一是不能通過這種用法降低某個結構成員和整個結構的內存對齊參數；二是在設置全局內存對齊參數的預編譯指令生效時，不能通過這種用法使某個結構成員或者整個結構的內存對齊參數超過全局內存對齊參數。
3. 上述兩項規則沒有在Windows平臺進行過驗證。
這裏對第二條規則做一點說明。首先是在任何情況下，試圖通過使用__attribute（（aligned（n）））降低某個結構成員或者整個結構的內存對齊參數的做法都是無效的，降低結構成員或整個結構內存對齊參數的唯一辦法是使用預編譯指令#pragma pack (N)。另外，__attribute（（aligned（n）））可以提高結構成員或者結構的內存對齊參數，但是最大不能超過通過預編譯指令定義的全局內存對齊參數；但是如果沒有使用該預編譯指令或者該預編譯指令無效（如Linux，gcc編譯環境下，N超過4），則沒有這個限制。這就意味着，此時儘管默認全局內存對齊參數爲4，但是可通過__attribute（（aligned（n）））強制定義某個結構成員（比如某個double變量）的內存對其參數爲8。
4. 示例
Linux，gcc編譯環境下，有如下定義的結構體：
#pragma pack(2)
struct Pool
{
char c;
char s;
double i __attribute((aligned (8)));
char d,e,f;
};
struct s2
{
char c;
struct Pool s1 __attribute((aligned(1)));
int d;
};
由於通過預編譯指令設置了全局內存對齊參數爲2，所以struct Pool中double i設置內存對齊參數爲8無效，整個Pool結構內存對齊參數爲2，結構所佔存儲空間大小爲14；struct s2中成員s1設置內存對齊參數爲1也無效，整個s2結構所佔存儲空間爲20。
還是上面的數據結構，如果將#pragma pack (2)屏蔽，那麼struct Pool中double i設置內存對齊參數爲8生效，整個Pool結構內存對齊參數爲8，結構所佔存儲空間大小爲24；struct s2中成員s1設置內存對齊參數爲1仍然無效，整個s2結構所佔存儲空間爲40。
5. 參考文章
主要包括但不僅限於：
1.
http://blog.csdn.net/wenddy112/articles/300583.aspx
2.
http://blog.csdn.net/sadgod/archive/2007/08/09/1733926.aspx
3.
http://topic.csdn.net/u/20080904/10/ffc6b178-8261-4d8d-b74c-aed1e497c875.html
4.
http://bbs.chinaunix.net/viewthread.php?tid=636323
5.
http://blog.chinaunix.net/u1/39518/showart_504959.html
=============================================================================================================================
一.內存對齊的初步講解
內存對齊可以用一句話來概括：
“數據項只能存儲在地址是數據項大小的整數倍的內存位置上”
例如int類型佔用4個字節，地址只能在0，4，8等位置上。
例1：
#include <stdio.h>
struct xx{
char b;
int a;
int c;
char d;
};
int main()
{
struct xx bb;
printf("&a = %p/n", &bb.a);
printf("&b = %p/n", &bb.b);
printf("&c = %p/n", &bb.c);
printf("&d = %p/n", &bb.d);
printf("sizeof(xx) = %d/n", sizeof(struct xx));
return 0;
}
執行結果如下：
&a = ffbff5ec
&b = ffbff5e8
&c = ffbff5f0
&d = ffbff5f4
sizeof(xx) = 16
會發現b與a之間空出了3個字節，也就是說在b之後的0xffbff5e9,0xffbff5ea,0xffbff5eb空了出來，a直接存儲在了0xffbff5ec， 因爲a的大小是4，只能存儲在4個整數倍的位置上。打印xx的大小會發現，是16，有些人可能要問，b之後空出了3個字節，那也應該是13啊？其餘的3個 呢？這個往後閱讀本文會理解的更深入一點，這裏簡單說一下就是d後邊的3個字節，也會浪費掉，也就是說，這3個字節也被這個結構體佔用了.
可以簡單的修改結構體的結構，來降低內存的使用，例如可以將結構體定義爲：
struct xx{
char b;
char d;
int a;
int c;
};
這樣打印這個結構體的大小就是12，省了很多空間，可以看出，在定義結構體的時候，一定要考慮要內存對齊的影響，這樣能使我們的程序佔用更小的內存。
二.操作系統的默認對齊係數
每 個操作系統都有自己的默認內存對齊係數，如果是新版本的操作系統，默認對齊係數一般都是8，因爲操作系統定義的最大類型存儲單元就是8個字節，例如 long long（爲什麼一定要這樣，在第三節會講解），不存在超過8個字節的類型（例如int是4，char是1，long在32位編譯時是4，64位編譯時是 8）。當操作系統的默認對齊係數與第一節所講的內存對齊的理論產生衝突時，以操作系統的對齊係數爲基準。
例如：
假設操作系統的默認對齊係數是4，那麼對與long long這個類型的變量就不滿足第一節所說的，也就是說long long這種結構，可以存儲在被4整除的位置上，也可以存儲在被8整除的位置上。
可以通過#pragma pack()語句修改操作系統的默認對齊係數，編寫程序的時候不建議修改默認對齊係數，在第三節會講解原因
例2：
#include <stdio.h>
#pragma pack(4)
struct xx{
char b;
long long a;
int c;
char d;
};
#pragma pack()
int main()
{
struct xx bb;
printf("&a = %p/n", &bb.a);
printf("&b = %p/n", &bb.b);
printf("&c = %p/n", &bb.c);
printf("&d = %p/n", &bb.d);
printf("sizeof(xx) = %d/n", sizeof(struct xx));
return 0;
}
打印結果爲：
&a = ffbff5e4
&b = ffbff5e0
&c = ffbff5ec
&d = ffbff5f0
sizeof(xx) = 20
發現佔用8個字節的a，存儲在了不能被8整除的位置上，存儲在了被4整除的位置上，採取了操作系統的默認對齊係數。
三.內存對齊產生的原因
內存對齊是操作系統爲了快速訪問內存而採取的一種策略，簡單來說，就是爲了放置變量的二次訪問。操作系統在訪問內存 時，每次讀取一定的長度（這個長度就是操作系統的默認對齊係數，或者是默認對齊係數的整數倍）。如果沒有內存對齊時，爲了讀取一個變量是，會產生總線的二 次訪問。
例如假設沒有內存對齊，結構體xx的變量位置會出現如下情況：
struct xx{
char b; //0xffbff5e8
int a; //0xffbff5e9
int c; //0xffbff5ed
char d; //0xffbff5f1
};
操作系統先讀取0xffbff5e8-0xffbff5ef的內存，然後在讀取0xffbff5f0-0xffbff5f8的內存，爲了獲得值c，就需要將兩組內存合併，進行整合，這樣嚴重降低了內存的訪問效率。（這就涉及到了老生常談的問題，空間和效率哪個更重要？這裏不做討論）。
這樣大家就能理解爲什麼結構體的第一個變量，不管類型如何，都是能被8整除的吧（因爲訪問內存是從8的整數倍開始的，爲了增加讀取的效率）！
內存對齊的問題主要存在於理解struct等複合結構在內存中的分佈。
首先要明白內存對齊的概念。
許多實際的計算機系統對基本類型數據在內存中存放的位置有限制，它們會要求這些數據的首地址的值是某個數k(通常它爲4或8)的倍數，這就是所謂的內存對齊。
這個k在不同的cpu平臺下，不同的編譯器下表現也有所不同。比如32位字長的計算機與16位字長的計算機。這個離我們有些遠了。我們的開發主要涉及兩大平臺，windows和linux（unix），涉及的編譯器也主要是microsoft編譯器(如cl),和gcc。
內存對齊的目的是使各個基本數據類型的首地址爲對應k的倍數，這是理解內存對齊方式的終極法寶。另外還要區分編譯器的分別。明白了這兩點基本上就能搞定所有內存對齊方面的問題。
不同編譯器中的k：
1、對於microsoft的編譯器，每種基本類型的大小即爲這個k。大體上char類型爲8，int爲32，long爲32，double爲64。
2、對於linux下的gcc編譯器，規定大小小於等於2的，k值爲其大小，大於等於4的爲4。
明白了以上的說明對struct等複合結構的內存分佈就應該很清楚了。
下面看一下最簡單的一個類型：struct中成員都爲基本數據類型，例如：
struct test1
{
char a;
short b;
int c;
long d;
double e;
};
在windows平臺，microsoft編譯器下：
假設從0地址開始，首先a的k值爲1，它的首地址可以使任意位置，所以a佔用第一個字節，即地址0；然後b的k值爲2，他的首地址必須是2的倍數，不能是1，所以地址1那個字節被填充，b首地址爲地址2，佔用地址2，3；然後到c，c的k值爲4，他的首地址爲4的倍數，所以首地址爲4，佔用地址4，5，6，7；再然後到d，d的k值也爲4，所以他的首地址爲8，佔用地址8，9，10，11。最後到e，他的k值爲8，首地址爲8的倍數，所以地址12，13，14，15被填充，他的首地址應爲16，佔用地址16-23。顯然其大小爲24。
這就是 test1在內存中的分佈情況。我們建立一個test1類型的變量，a、b、c、d、e分別賦值2、4、8、16、32。然後從低地址依次打印出內存中每個字節對應的16進制數爲：
2 0 4 0 8 0 0 0 10 0 0 0 0 0 0 0 0 0 0 0 0 0 40 40
驗證：
顯然推斷是正確的。
在linux平臺，gcc編譯器下：
假設從0地址開始，首先a的k值爲1，它的首地址可以使任意位置，所以a佔用第一個字節，即地址0；然後b的k值爲2，他的首地址必須是2的倍數，不能是1，所以地址1那個字節被填充，b首地址爲地址2，佔用地址2，3；然後到c，c的k值爲4，他的首地址爲4的倍數，所以首地址爲4，佔用地址4，5，6，7；再然後到d，d的k值也爲4，所以他的首地址爲8，佔用地址8，9，10，11。最後到e，從這裏開始與microsoft的編譯器開始有所差異，他的k值爲不是8，仍然是4，所以其首地址是12，佔用地址12-19。顯然其大小爲20。
驗證：
我們建立一個test1類型的變量，a、b、c、d、e分別賦值2、4、8、16、32。然後從低地址依次打印出內存中每個字節對應的16進制數爲：
2 0 4 0 8 0 0 0 10 0 0 0 0 0 0 0 0 0 40 40
顯然推斷也是正確的。
接下來，看一看幾類特殊的情況，爲了避免麻煩，不再描述內存分佈，只計算結構大小。
第一種：嵌套的結構
struct test2
{
char f;
struct test1 g;
};
在windows平臺，microsoft編譯器下：
這種情況下如果把test2的第二個成員拆開來，研究內存分佈，那麼可以知道，test2的成員f佔用地址0，g.a佔用地址1，以後的內存分佈不變，仍然滿足所有基本數據成員的首地址都爲其對應k的倍數這一原則，那麼test2的大小就還是24了。但是實際上test2的大小爲32，這是因爲：不能因爲test2的結構而改變test1的內存分佈情況，所以爲了使test1種各個成員仍然滿足對齊的要求，f成員後面需要填充一定數量的字節，不難發現，這個數量應爲7個，才能保證test1的對齊。所以test2相對於test1來說增加了8個字節，所以test2的大小爲32。
在linux平臺，gcc編譯器下：
同樣，這種情況下如果把test2的第二個成員拆開來，研究內存分佈，那麼可以知道，test2的成員f佔用地址0，g.a佔用地址1，以後的內存分佈不變，仍然滿足所有基本數據成員的首地址都爲其對應k的倍數這一原則，那麼test2的大小就還是20了。但是實際上test2的大小爲24，同樣這是因爲：不能因爲test2的結構而改變test1的內存分佈情況，所以爲了使test1種各個成員仍然滿足對齊的要求，f成員後面需要填充一定數量的字節，不難發現，這個數量應爲3個，才能保證test1的對齊。所以test2相對於test1來說增加了4個字節，所以test2的大小爲24。
第二種：位段對齊
struct test3
{
unsigned int a:4;
unsigned int b:4;
char c;
};
或者
struct test3
{
unsigned int a:4;
int b:4;
char c;
};
在windows平臺，microsoft編譯器下：
相鄰的多個同類型的數(帶符號的與不帶符號的，只要基本類型相同，也爲相同的數),如果他們佔用的位數不超過基本類型的大小，那麼他們可作爲一個整體來看待。不同類型的數要遵循各自的對齊方式。
如：test3中，a、b可作爲一個整體，他們作爲一個int型數據來看待，所以test3的大小爲8字節。並且a與b的值在內存中從低位開始依次排列，位於4字節區域中的前0-3位和4-7位
如果test4位以下格式
struct test4
{
unsigned int a:30;
unsigned int b:4;
char c;
};
那麼test4的大小就爲12個字節，並且a與b的值分別分佈在第一個4字節的前30位，和第二個4字節的前4位。
如過test5是以下形式
struct test5
{
unsigned int a:4;
unsigned char b:4;
char c;
};
那麼由於int和char不同類型，他們分別以各自的方式對齊，所以test5的大小應爲8字節，a與b的值分別位於第一個4字節的前4位和第5個字節的前4位。
在linux平臺，gcc編譯器下：
struct test3
{
unsigned int a:4;
unsigned int b:4;
char c;
};
gcc下，相鄰各成員，不管類型是否相同，佔的位數之和超過這些成員中第一個的大小的時候，在結構中以k值爲1對齊，在結構外k值爲其基本類型的值。不超過的情況下在內存中依次排列。
如test3，其大小爲4。a，b的值在內存中依次排列分別爲第一個四字節中的0-3和4-7位。
如果test4位以下格式
struct test4
{
unsigned int a:20;
unsigned char b:4;
char c;
};
test4的大小爲4個字節，並且a與b的值分別分佈在第一個4字節的0-19位，和20-23位，c存放在第4個字節中。
如過test5是以下形式
struct test5
{
unsigned int a:10;
unsigned char b:4;
short c;
};
那麼test5的大小應爲4字節，a，b的值爲0-9位和10-13位。c存放在後兩個字節中。如果a的大小變成了20
那麼test5的大小應爲8字節。即
struct test6
{
unsigned int a:20;
unsigned char b:4;
short c;
};
此時，test6的a、b共佔用0，1，2共3字節，c的k值爲2，其實可以4位首位置，但是在結構外，a要以int的方式對齊。也就是說連續兩個test6對象在內存中存放的話，a的首位置要保證爲4的倍數，那麼c後面必須多填充2位。所以test6的大小爲8個字節。
關於位段結構的部分是比較複雜的。暫時我就知道這麼多。