強調一點：

#pragma pack(4)

typedef struct

{

    char buf[3];

    word a;

}kk;

#pragma pack()

對齊的原則是min(sizeof(word ),4)=2,因此是2位元組對齊，而不是我們認為的4位元組對齊。

這裡有三點很重要:
1.每個成員分別按自己的方式對齊,並能最小化長度
2.複雜型別(如結構)的預設對齊方式是它最長的成員的對齊方式,這樣在成員是複雜型別時,可以最小化長度
3.對齊後的長度必須是成員中最大的對齊引數的整數倍,這樣在處理陣列時可以保證每一項都邊界對齊

補充一下,對於陣列,比如:
char a[3];這種,它的對齊方式和分別寫3個char是一樣的.也就是說它還是按1個位元組對齊.
如果寫: typedef char Array3[3];
Array3這種型別的對齊方式還是按1個位元組對齊,而不是按它的長度.
不論型別是什麼,對齊的邊界一定是1,2,4,8,16,32,64....中的一個.

宣告：
整理自網路達人們的帖子，部分參照MSDN。

作用：
指定結構體、聯合以及類成員的packing alignment;

語法：
#pragma pack( [show] | [push | pop] [, identifier], n )

說明：
1，pack提供資料宣告級別的控制，對定義不起作用；
2，呼叫pack時不指定引數，n將被設成預設值；
3，一旦改變資料型別的alignment，直接效果就是佔用memory的減少，但是performance會下降；

語法具體分析：
1，show：可選引數；顯示當前packing aligment的位元組數，以warning message的形式被顯示；
2，push：可選引數；將當前指定的packing alignment數值進行壓棧操作，這裡的棧是the internal compiler stack，同時設定當前的packing alignment為n；如果n沒有指定，則將當前的packing alignment數值壓棧；
3，pop：可選引數；從internal compiler stack中刪除最頂端的record；如果沒有指定n，則當前棧頂record即為新的packing alignment數值；如果指定了n，則n將成為新的packing aligment數值；如果指定了identifier，則internal compiler stack中的record都將被pop直到identifier被找到，然後pop出identitier，同時設定packing alignment數值為當前棧頂的record；如果指定的identifier並不存在於internal compiler stack，則pop操作被忽略；
4，identifier：可選引數；當同push一起使用時，賦予當前被壓入棧中的record一個名稱；當同pop一起使用時，從internal compiler stack中pop出所有的record直到identifier被pop出，如果identifier沒有被找到，則忽略pop操作；
5，n：可選引數；指定packing的數值，以位元組為單位；預設數值是8，合法的數值分別是1、2、4、8、16。

重要規則：
1，複雜型別中各個成員按照它們被宣告的順序在記憶體中順序儲存，第一個成員的地址和整個型別的地址相同；
2，每個成員分別對齊，即每個成員按自己的方式對齊，並最小化長度；規則就是每個成員按其型別的對齊引數（通常是這個型別的大小）和指定對齊引數中較小的一個對齊；
3，結構、聯合或者類的資料成員，第一個放在偏移為0的地方；以後每個資料成員的對齊，按照#pragma pack指定的數值和這個資料成員自身長度兩個中比較小的那個進行；也就是說，當#pragma pack指定的值等於或者超過所有資料成員長度的時候，這個指定值的大小將不產生任何效果；
4，複雜型別（如結構）整體的對齊是按照結構體中長度最大的資料成員和#pragma pack指定值之間較小的那個值進行；這樣在成員是複雜型別時，可以最小化長度；
5，結構整體長度的計算必須取所用過的所有對齊引數的整數倍，不夠補空位元組；也就是取所用過的所有對齊引數中最大的那個值的整數倍，因為對齊引數都是2的n次方；這樣在處理陣列時可以保證每一項都邊界對齊；

更改c編譯器的預設位元組對齊方式：
在預設情況下，c編譯器為每一個變數或資料單元按其自然對界條件分配空間；一般地可以通過下面的兩種方法來改變預設的對界條件：
方法一：
使用#pragma pack(n)，指定c編譯器按照n個位元組對齊；
使用#pragma pack()，取消自定義位元組對齊方式。

方法二：
__attribute(aligned(n))，讓所作用的資料成員對齊在n位元組的自然邊界上；如果結構中有成員的長度大於n，則按照最大成員的長度來對齊；
__attribute((packed))，取消結構在編譯過程中的優化對齊，按照實際佔用位元組數進行對齊。

綜上所述，下面給出例子並詳細分析：

例子一：
#pragma pack(4)
class TestB
{
public:
int aa; //第一個成員，放在[0,3]偏移的位置，
　　char a; //第二個成員，自身長為1，#pragma pack(4),取小值，也就是1，所以這個成員按一位元組對齊，放在偏移[4]的位置。
　　short b; //第三個成員，自身長2，#pragma pack(4)，取2，按2位元組對齊，所以放在偏移[6,7]的位置。
　　char c; //第四個，自身長為1，放在[8]的位置。
};
可見，此類實際佔用的記憶體空間是9個位元組。根據規則5，結構整體的對齊是min( sizeof( int ), pack_value ) = 4，所以sizeof( TestB ) = 12;

例子二：
#pragma pack(2)
class TestB
{
public:
int aa; //第一個成員，放在[0,3]偏移的位置，
　　char a; //第二個成員，自身長為1，#pragma pack(4),取小值，也就是1，所以這個成員按一位元組對齊，放在偏移[4]的位置。
　　short b; //第三個成員，自身長2，#pragma pack(4)，取2，按2位元組對齊，所以放在偏移[6,7]的位置。
　　char c; //第四個，自身長為1，放在[8]的位置。
};
可見結果與例子一相同，各個成員的位置沒有改變，但是此時結構整體的對齊是min( sizeof( int ), pack_value ) = 2，所以sizeof( TestB ) = 10；

例子三：
#pragma pack(4)
class TestC
{
public:
char a; //第一個成員，放在[0]偏移的位置，
　　short b; //第二個成員，自身長2，#pragma pack(4)，取2，按2位元組對齊，所以放在偏移[2,3]的位置。
　　char c; //第三個，自身長為1，放在[4]的位置。
};
整個類的實際記憶體消耗是5個位元組，整體按照min( sizeof( short ), 4 ) = 2對齊，所以結果是sizeof( TestC ) = 6；

例子四：
struct Test
{
char x1; //第一個成員，放在[0]位置，
short x2; //第二個成員，自身長度為2，按2位元組對齊，所以放在偏移[2,3]的位置，
float x3; //第三個成員，自身長度為4，按4位元組對齊，所以放在偏移[4,7]的位置，
char x4; //第四個陳冠，自身長度為1，按1位元組對齊，所以放在偏移[8]的位置，
};
所以整個結構體的實際記憶體消耗是9個位元組，但考慮到結構整體的對齊是4個位元組，所以整個結構佔用的空間是12個位元組。

例子五：
#pragma pack(8)

struct s1
{
short a; //第一個，放在[0,1]位置，
long b; //第二個，自身長度為4，按min(4, 8) = 4對齊，所以放在[4,7]位置
};
所以結構體的實際記憶體消耗是8個位元組，結構體的對齊是min( sizeof( long ), pack_value ) = 4位元組，所以整個結構佔用的空間是8個位元組。

struct s2
{
char c; //第一個，放在[0]位置，
s1 d; //第二個，根據規則四，對齊是min( 4, pack_value ) = 4位元組，所以放在[4,11]位置,
long long e; //第三個，自身長度為8位元組，所以按8位元組對齊，所以放在[16,23]位置，
};
所以實際記憶體消耗是24自己，整體對齊方式是8位元組，所以整個結構佔用的空間是24位元組。

#pragma pack()
所以：
sizeof(s2) = 24, s2的c後面是空了3個位元組接著是d。