C語言字節對齊1 2 3 4 5

不一樣系統下的C語言類型長度

Data Type	ILP32	ILP64	LP64	LLP64
char	8	8	8	8
short	16	16	16	16
int	32	64	32	32
long	32	64	64	32
long long	64	64	64	64
pointer	32	64	64	64

絕大部分64位的Unix，linux都是使用的LP64模型；32位Linux系統是ILP32模型；64位的Windows使用的是LLP64(long long and point 64)模型。html

基本概念

許多計算機系統對基本數據類型合法地址作出了一些限制，要求某種類型對象的地址必須是某個值K(一般是2，4或8)的倍數。這種對齊限制簡化了造成處理器和存儲器系統之間的接口的硬件設計。對齊跟數據在內存中的位置有關。若是一個變量的內存地址正好位於它長度的整數倍，他就被稱作天然對齊。好比在32位cpu下，假設一個整型變量的地址爲0x00000004，那它就是天然對齊的。java

爲何要字節對齊

須要字節對齊的根本緣由在於CPU訪問數據的效率問題。例如，假設一個處理器老是從存儲器中取出8個字節，則地址必須爲8的倍數。若是咱們能保證將全部的double類型數據的地址對齊成8的倍數，那麼就能夠用一個存儲器操做來讀或者寫值了。不然，咱們可能須要執行兩次存儲器訪問，由於對象可能被分放在兩個8字節存儲塊中。linux

另外，假設一個整型變量的地址不是天然對齊，好比爲0x00000002，則CPU若是取它的值的話須要訪問兩次內存，第一次取從0x00000002-0x00000003的一個short，第二次取從0x00000004-0x00000005的一個short而後組合獲得所要的數據；若是變量在0x00000003地址上的話則要訪問三次內存，第一次爲char，第二次爲short，第三次爲char，而後組合獲得整型數據。而若是變量在天然對齊位置上，則只要一次就能夠取出數據。ios

各個硬件平臺對存儲空間的處理上有很大的不一樣，一些平臺對某些特定類型的數據只能從某些特定地址開始存取。好比有些架構的CPU在訪問一個沒有進行對齊的變量的時候會發生錯誤，那麼在這種架構下編程必須保證字節對齊。好比sparc系統，若是取未對齊的數據會發生錯誤，舉個例：c++

char ch[8];
char *p = &ch[1];
int i = *(int *)p;

運行時會報segment error，而在x86上就不會出現錯誤，只是效率降低。算法

如何處理字節對齊

先讓咱們看編譯器是按照什麼樣的原則進行對齊的：shell

數據類型自身的對齊值：爲指定平臺上基本類型的長度。對於char型數據，其自身對齊值爲1，對於short型爲2，對於int,float,double類型，其自身對齊值爲4，單位字節。
結構體或者類的自身對齊值：其成員中自身對齊值最大的那個值。
指定對齊值：#pragma pack (value)時的指定對齊值value。
數據成員、結構體和類的有效對齊值：自身對齊值和指定對齊值中小的那個值。

對於標準數據類型，它的地址只要是它的長度的整數倍就好了，而非標準數據類型按下面的原則對齊：
數組：按照基本數據類型對齊，第一個對齊了後面的天然也就對齊了。
聯合：按其包含的長度最大的數據類型對齊。
結構體：結構體中每一個數據類型都要對齊。編程

當數據類型爲結構體時，編譯器可能須要在結構體字段的分配中插入間隙，以保證每一個結構元素都知足它的對齊要求。第一個數據變量的起始地址就是數據結構的起始地址。結構體的成員變量要對齊排放（對於非對齊成員須要在其前面填充一些字節，保證其在對齊位置上），結構體自己也要根據自身的有效對齊值圓整(就是結構體總長度須要是結構體有效對齊值的整數倍)，此時可能須要在結構末尾填充一些空間，以知足結構體總體的對齊—-向結構體元素中最大的元素對齊。windows

經過上面的分析，對結構體進行字節對齊，咱們須要知道四個值：centos

指定對齊值：代碼中指定的對齊值，記爲packLen；
默認對齊值：結構體中每一個數據成員及結構體自己都有默認對齊值，記爲defaultLen；
成員偏移量：即相對於結構體起始位置的長度，記爲offset；
成員長度：結構體中每一個數據成員的長度（注結構體成員爲補齊以後的長度），記爲memberLen。

及兩個規則：

對齊規則： offset % vaildLen = 0，其中vaildLen爲有效對齊值vaildLen = min(packLen, defaultLen)；
填充規則：如成員變量不遵照對齊規則，則須要對其補齊；在其前面填充一些字節保證該成員對齊。需填充的字節數記爲pad

Linux和Microsoft Windows的對齊方式

一.Linux的對齊策略:

在Linux中2字節數據類型(例如short)的地址必須是2的倍數，而較大的數據類型(例如int，int *，float和double)的地址必須是4的倍數。也就是說Linux下要麼2字節對齊，要麼4字節對齊，沒有其餘格式的對齊。

二.Microsoft Windows的對齊策略:

在Windows中對齊要求更嚴–任何K字節基本對象的地址都必須是K的倍數，K=2，4，或者8.特別地，double或者long long類型數據的地址應該是8的倍數。能夠看出Windows的對齊策略和Linux仍是不一樣的。

更改C編譯器的缺省字節對齊方式

在缺省狀況下，C編譯器爲每個變量或是數據單元按其天然對界條件分配空間。通常地，能夠經過下面的方法來改變缺省的對界條件：

使用僞指令#pragma pack (n)，C編譯器將按照n個字節對齊。
使用僞指令#pragma pack ()，取消自定義字節對齊方式。

另外，還有以下的一種方式：

__attribute((aligned (n)))，讓所做用的結構成員對齊在n字節天然邊界上。若是結構中有成員的長度大於n，則按照最大成員的長度來對齊。
__attribute__ ((packed))，取消結構在編譯過程當中的優化對齊，按照實際佔用字節數進行對齊。

字節對齊的做用不只是便於cpu快速訪問，同時合理的利用字節對齊能夠有效地節省存儲空間。

對於32位機來講，4字節對齊可以使cpu訪問速度提升，好比說一個long類型的變量，若是跨越了4字節邊界存儲，那麼cpu要讀取兩次，這樣效率就低了。可是在32位機中使用1字節或者2字節對齊，反而會使變量訪問速度下降。因此這要考慮處理器類型，另外還得考慮編譯器的類型。在vc中默認是4字節對齊的，GNU gcc 也是默認4字節對齊。

何時須要設置對齊

在設計不一樣CPU下的通訊協議時，或者編寫硬件驅動程序時寄存器的結構這兩個地方都須要按一字節對齊。即便看起來原本就天然對齊的也要使其對齊，以避免不一樣的編譯器生成的代碼不同.

結構體舉例

例子1

/************************ > File Name: struct_test.c > Author:Marvin > Created Time: Thu 22 Mar 2018 07:19:46 PM CST **********************/

#include<stdio.h>


int main()
{
    struct test {
        char a;
        short b;
        int c;
        long d;
    };
    struct test t = {'a',11,11,11};

    printf("size of struct t = %u\n", sizeof(t));

    return 0;
}

在64位centos上編譯編譯後結構struct test的佈局以下:

因爲要保證結構體每一個元素都要數據對齊，所以必須在a和b之間插入1字節的間隙使得後面的short元素2字節對齊int元素4字節對齊long元素8字節對齊，這樣最終test結構大小爲16字節。

運行程序結果爲:

size of struct t = 16

例子2

如今考慮這樣一個結構體：

struct test2 {
    int a;
    long b;
    char c;
};
struct test2 t2 = {11,11,'c'};

在64位centos上編譯編譯後結構struct test2的佈局以下:

結構體struct test2的天然對界條件爲8字節，因此須要在最後的char型數據後面再填充7個字節使得結構體總體對齊。

運行程序結構爲

size of struct test2 = 24

例子3

不妨將結構體struct test2裏面成員的順序從新排列一下：

struct test3 {
    char c;
    int a;
    long b;
};
struct test3 t3 = {'c',11,11};

在64位centos上編譯編譯後結構struct test2的佈局以下:

運行結果爲：

size of struct test3 = 16

可見適當地編排結構體成員地順序，能夠在保存相同信息地狀況下儘量節約內存空間。

例子4

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;其實若是就這一個就來講它已將知足字節對齊了,由於它的起始地址是0,所以確定是對齊的,之因此在後面補充2個字節,是由於編譯器爲了實現結構數組的存取效率,試想若是咱們定義了一個結構B的數組,那麼第一個結構起始地址是0沒有問題,可是第二個結構呢?按照數組的定義,數組中全部元素都是緊挨着的,若是咱們不把結構的大小補充爲4的整數倍,那麼下一個結構的起始地址將是0x0000A,這顯然不能知足結構的地址對齊了,所以咱們要把結構補充成有效對齊大小的整數倍.其實諸如:對於char型數據，其自身對齊值爲1，對於short型爲2，對於int,float,double類型，其自身對齊值爲4，這些已有類型的自身對齊值也是基於數組考慮的,只是由於這些類型的長度已知了,因此他們的自身對齊值也就已知了.
例子5

#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，因此順序存放在0x000二、0x000三、0x000四、0x0005四個連續字節中，符合0x0002%2=0。第三個變量c的自身對齊值爲2，因此有效對齊值爲2，順序存放在0x000六、0x0007中，符合0x0006%2=0。因此從0x0000到0x00007共八字節存放的是C的變量。又C的自身對齊值爲4，因此C的有效對齊值爲2。又8%2=0,C只佔用0x0000到0x0007的八個字節。因此sizeof(struct C)=8.

對於結構體嵌套地狀況，結構體對齊算法思想：深度優先填充。

padLen = getPadLen(offset , defaultLen);
int getPadLen(int offsetLen, int defaultLen)
{
  int vaildLen = min(packLen,defaultLen);
  if(0 == vaildLen || 0 == offsetLen % vaildLen)
  {
    return 0;
  }
  return vaildLen - (offsetLen % vaildLen);
}

先對齊內層結構體：對每一個數據成員計算其defaultLen、memberLen和offset；

再遍歷每一個數據成員時計算：對於基本數據類型成員defaultLen=memberLen；對於結構體成員defaultLen等於它的全部成員的最大的memberLen；遍歷時對成員的memberLen進行累加，獲得當前成員的offsetLen；

運用對齊及填充規則：在當前結構體成員前填充padLen個字節；

下面是結構體做爲成員的例子：

struct test1 {
    int a;
    long b;
};
struct test4 {
    char a;
    struct test1 b;
    int c;
};
struct test4 t4 = {'a', {11,11},11}

test1的內存分佈:

test4的內存分佈:

字節對齊可能帶來的隱患

代碼中關於對齊的隱患，不少是隱式的。好比在強制類型轉換的時候。例如：

unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;

最後兩句代碼，從奇數邊界去訪問unsignedshort型變量，顯然不符合對齊的規定。
在x86上，相似的操做只會影響效率，可是在MIPS或者sparc上，可能就是一個error,由於它們要求必須字節對齊.

如何查找與字節對齊方面的問題

若是出現對齊或者賦值問題首先查看

編譯器的big little端設置
看這種體系自己是否支持非對齊訪問
若是支持看設置了對齊與否,若是沒有則看訪問時須要加某些特殊的修飾來標誌其特殊訪問操做

舉例：

#include<iostream>

using namespace std;

//windows 64 位默認 結構體對齊係數爲8，32位 結構體對齊係數爲4

//測試系統對齊係數
// #pragma pack(8) my_struct_1 爲16字節
// #pragma pack(4) my_struct_1 爲12字節
// 不加#pragma pack(8) my_struct_1 爲16字節
//顧系統默認對齊係數爲8

struct my_struct_1
{
    char a;     //1
    double b;   //以前補7 +8 8/8==1
};

#pragma pack(4)
struct my_struct_2
{
    char a;    //1
    double b;  //3+8
    int c;     //4 16/4=4
};
#pragma pack()

#pragma pack(2)
struct my_struct_3
{
    char a;    //1
    double b;  //1+8
    int c;     //4 14/2
};
#pragma pack()

#pragma pack(4)
struct my_struct_4
{
    char a[5];  //5
    double b;   //3+8 16/4
};
#pragma pack()

#pragma pack(2)
struct my_struct_5
{
    char a[5];  //5
    double b;   //1+8 14/2
};
#pragma pack()

#pragma pack(4)
struct my_struct_6
{
    char a;    //1
    char b[3]; //3
    char c;    //1 1+3+1
};
#pragma pack()

#pragma pack(4)
struct my_struct_7
{
    char a;    //1
    char b[3]; //3
    char c;    //1 
    int d;     //補齊 3 +4 
};
#pragma pack()

#pragma pack(4)
struct test
{
char x1;   //1
short x2;  //補齊1+ 2
float x3;  //4
char x4;   //1 補齊+3 
};
#pragma pack()

int main()
{
    cout<<"char:"<<sizeof(char)<<endl;
    cout<<"short:"<<sizeof(short)<<endl;
    cout<<"int:"<<sizeof(int)<<endl;
    cout<<"long:"<<sizeof(long)<<endl;
    cout<<"float:"<<sizeof(float)<<endl;
    cout<<"double:"<<sizeof(double)<<endl;
    cout<<"long double:"<<sizeof(long double)<<endl;

    cout<<sizeof(my_struct_1)<<endl;//8
    cout<<sizeof(my_struct_2)<<endl;//16
    cout<<sizeof(my_struct_3)<<endl;//14
    cout<<sizeof(my_struct_4)<<endl;//16
    cout<<sizeof(my_struct_5)<<endl;//14
    cout<<sizeof(my_struct_6)<<endl;//5
    cout<<sizeof(my_struct_7)<<endl;//12

    cout<<sizeof(test)<<endl;//12

    system("pause");
    return 0;
}

C語言字節對齊詳解

C語言字節對齊12345