內存對齊

一.內存對齊的初步講解

內存對齊能夠用一句話來歸納：「數據項只能存儲在地址是數據項大小的整數倍的內存位置上」。例如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：

一、對於microsoft的編譯器，每種基本類型的大小即爲這個k。大致上char類型爲8，int爲32，long爲32，double爲64。

二、對於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分別賦值二、四、八、1六、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分別賦值二、四、八、1六、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個字節。

關於位段結構的部分是比較複雜的。暫時我就知道這麼多。