stm32做串列埠或網路傳輸資料時，經常需要用結構體定義幀格式。如果按照keil預設的對齊方式（4位元組對齊），經常會出現結構體中補零的問題，造成幀格式錯誤。所以，在定義結構體型別時，最好把結構體對齊方式改為1位元組對齊，防止出錯。理論和方法見下面轉載的文章。

#pragma pack(4)   //按4位元組對齊，但實際上由於結構體中單個成員的最大佔用位元組數為2位元組，因此實際還是按2位元組對齊

typedef struct

{

    char buf[3];//buf[1]按1位元組對齊，buf[2]按1位元組對齊，由於buf[3]的下一成員word a是按兩位元組對齊，因此buf[3]按1位元組對齊後，後面只需補一空位元組

    word a;      //#pragma pack(4)，取小值為2，按2位元組對齊。

}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次方；這樣在處理陣列時可以保證每一項都邊界對齊；

對齊的演算法： 由於各個平臺和編譯器的不同，現以本人使用的gcc version 3.2.2編譯器（32位x86平臺）為例子，來討論編譯器對struct資料結構中的各成員如何進行對齊的。

在相同的對齊方式下，結構體內部資料定義的順序不同，結構體整體佔據記憶體空間也不同，如下：

設結構體如下定義：

struct A {

int a;             //a的自身對齊值為4，偏移地址為0x00~0x03，a的起始地址0x00滿足0x00%4=0;

char b;           //b的自身對齊值為1，由於緊跟a之後的地址，即0x04滿足0x04%1=0，所以b存放在0x04地址空間

short c;          //c的自身對齊值為2，由於緊跟b之後的地址0x05%2不是0，而0x06%2=0，因此c的存放起始地址為0x06，存放在0x06~0x07空間。

                       在b和c之間的0x05地址 則補空位元組。

};

結構體A中包含了4位元組長度的int一個，1位元組長度的char一個和2位元組長度的short型資料一個。所以A用到的空間應該是7位元組。但是因為編譯器要對資料成員在空間上進行對齊。由於結構體自身對齊值取資料成員中自身對齊值的最大值，即4，並且0x00~0x07的8位元組空間滿足8%4=0，所以sizeof(strcut A)值為8。

現在把該結構體調整成員變數的順序。

struct B {

char b;          //b的自身對齊值為1，其起始地址為0x00，由於滿足0x00%1=0，所以b存放在0x00地址空間

int a;             //a的自身對齊值為4，由於緊跟b之後的地址0x01%4不是0，而0x04%4=0，因此c的存放起始地址為0x04，存放在0x04~0x07空間。

                       在b和a之間的0x01~0x03地址則補3個空位元組。

short c;          //c的自身對齊值為2，由於緊跟a之後的地址0x08%2=0，因此c的存放起始地址為0x08，存放在0x08~0x09空間。

};

這時候同樣是總共7個位元組的變數，但是由於結構體自身對齊值取資料成員中自身對齊值的最大值，即4，並且0x00~0x09的10位元組空間不滿足10%4=0，而12%4=0，所以sizeof(struct B)的值卻是12，即在緊跟c之後的0x0A~0x0B地址還需補兩個空位元組，使得整個結構體佔用的位元組空間為12個位元組。

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

#pragma pack (2) /*指定按2位元組對齊，等價於#pragma pack(push,2)*/

struct C {

char b;

int a;

short c;

};

#pragma pack () /*取消指定對齊，恢復預設對齊,等價於#pragma pack(pop)*/

sizeof(struct C)值是8。

修改對齊值為1：

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

struct D {

char b;

int a;

short c;

};

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

sizeof(struct D)值為7。

對於char型資料，其自身對齊值為1，對於short型為2，對於int,float,long型別，其自身對齊值為4，double,long long型別，其自身對齊值為8，單位位元組。

這裡面有四個概念值：

1.資料型別自身的對齊值：就是上面交代的基本資料型別的自身對齊值。

2.指定對齊值：#pragma 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的自身對齊值為其變數中最大對齊值(這裡是a）和指定對齊值(這裡是4)中較小的那個，所以就是4，所以結構體的有效對齊值也是4。根據結構體圓整的要求，0x0009到0x0000=10位元組，（10+2）%4=0。所以0x0000A到0x000B也為結構體B所佔用。故B從0x0000到0x000B共有12個位元組,sizeof(struct B)=12;

同理,分析上面例子C：

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

struct C {

char b;

int a;

short c;

};

#pragma 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.

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

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

比如：

typedef struct

{

　　...

}__attribute__((aligned(4))) param_t;

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

例子一：
#pragma pack(4)
class TestB
{
   public:
      int aa;   //第一個成員，放在[0,3]偏移的位置，
　　char a;   //第二個成員，自身長為1，#pragma pack(4),取小值，也就是1，所以這個成員按一位元組對齊，放在偏移[4]的位置。由於下一成員short b是按2位元組對齊，因此char a後面只需補一個空位元組
　　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; char a 佔用一個位元組，後面補3個空位元組；short b和char c可以放在同一4位元組空間中，後面只需補一個空位元組。）

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

例子三：
#pragma pack(4)
class TestC
{
  public:
     char a;    //第一個成員，放在[0]偏移的位置，由於下一成員short b按2位元組對齊，因此char a後面只弱補一個空位元組
　　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位元組對齊，因此char x1後面只需補一個空位元組，
    short x2; //第二個成員，自身長度為2，按2位元組對齊，所以放在偏移[2,3]的位置，
    float x3;  //第三個成員，自身長度為4，按4位元組對齊，所以放在偏移[4,7]的位置，
    char x4;  //第四個成員，自身長度為1，按1位元組對齊，所以放在偏移[8]的位置，
};
所以整個結構體的實際記憶體消耗是9個位元組，（這裡有疑問？按我的理解，考慮到結構整體的對齊是4個位元組，所以整個結構佔用的空間是12個位元組。char x1和short x2共用一個4位元組空間，後面補一個空位元組；char x4後面需要補3個空位元組。）

例子五：
#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位元組（由於s1佔用了8個位元組，這裡為什麼不是8位元組？？），所以放在[4,11]位置,
long long e; //第三個，自身長度為8位元組，所以按8位元組對齊，所以放在[16,23]位置，
};
所以實際記憶體消耗是24位元組。整體對齊方式是8位元組，所以整個結構佔用的空間是24位元組。

#pragma pack()

所以：sizeof(s2) = 24, char c後面是空了3個位元組接著是s1 d, s1 d後面又補了4個空位元組（這裡有疑問？？按我的理解，char c佔一個位元組，後面補7個位元組；s1 d佔8個位元組；long long e佔8個位元組。