編譯器默認對齊

Ⅰ 內存對齊的詳細解釋

大部分的參考資料都是如是說的：
1、平台原因(移植原因)：不是所有的硬體平台都能訪問任意地址上的任意數據的；某些硬體平台只能在某些地址處取某些特定類型的數據，否則拋出硬體異常。
2、性能原因：數據結構(尤其是棧)應該盡可能地在自然邊界上對齊。原因在於，為了訪問未對齊的內存，處理器需要作兩次內存訪問；而對齊的內存訪問僅需要一次訪問。 每個特定平台上的編譯器都有自己的默認「對齊系數」(也叫對齊模數)。程序員可以通過預編譯命令#pragma pack(n)，n=1,2,4,8,16來改變這一系數，其中的n就是你要指定的「對齊系數」。
規則：
1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。
2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行。
3、結合1、2可推斷：當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果。
Win32平台下的微軟C編譯器(cl.exefor 80×86)的對齊策略：
1)結構體變數的首地址是其最長基本類型成員的整數倍；
備註：編譯器在給結構體開辟空間時，首先找到結構體中最寬的基本數據類型，然後尋找內存地址能是該基本數據類型的整倍的位置，作為結構體的首地址。將這個最寬的基本數據類型的大小作為上面介紹的對齊模數。
2)結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal adding）；
備注:為結構體的一個成員開辟空間之前，編譯器首先檢查預開辟空間的首地址相對於結構體首地址的偏移是否是本成員的整數倍，若是，則存放本成員，反之，則在本成員和上一個成員之間填充一定的位元組，以達到整數倍的要求，也就是將預開辟空間的首地址後移幾個位元組。
3)結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要，編譯器會在最末一個成員之後加上填充位元組（trailing padding）。
備註：結構體總大小是包括填充位元組，最後一個成員滿足上面兩條以外，還必須滿足第三條，否則就必須在最後填充幾個位元組以達到本條要求。
4) 結構體內類型相同的連續元素將在連續的空間內，和數組一樣。
5) 如果結構體內存在長度大於處理器位數的元素，那麼就以處理器的倍數為對齊單位；否則，如果結構體內的元素的長度都小於處理器的倍數的時候，便以結構體裡面最長的數據元素為對齊單位。 我們通過一系列例子的詳細說明來證明這個規則吧!
我試驗用的編譯器包括GCC 3.4.2和VC6.0的C編譯器，平台為Windows XP + Sp2。
我們將用典型的struct對齊來說明。首先我們定義一個struct：
#pragma pack(n) /* n = 1, 2, 4, 8, 16 */
struct test_t {
int a;
char b;
short c;
char d[6];
};
#pragma pack(n)
首先我們首先確認在試驗平台上的各個類型的size，經驗證兩個編譯器的輸出均為：
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4
我們的試驗過程如下：通過#pragma pack(n)改變「對齊系數」，然後察看sizeof(struct test_t)的值。
1、1位元組對齊(#pragma pack(1))
輸出結果：sizeof(struct test_t) = 13[兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(1)
struct test_t {
int a; /* int型，長度4 > 1 按1對齊；起始offset=0 0%1=0；存放位置區間[0,3] */
char b; /* char型，長度1 = 1 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 > 1 按1對齊；起始offset=5 5%1=0；存放位置區間[5,6] */
char d[6]; /* char型，長度1 = 1 按1對齊；起始offset=7 7%1=0；存放位置區間[7,C] */
};/*char d[6]要看成6個char型變數*/
#pragma pack()
成員總大小=13
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 1) = 1
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 13 /*13%1=0*/ [注1]
2、2位元組對齊(#pragma pack(2))
輸出結果：sizeof(struct test_t) = 14 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(2)
struct test_t {
int a; /* int型，長度4 > 2 按2對齊；起始offset=0 0%2=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 2 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 = 2 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 2 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 2) = 2
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 14 /* 14%2=0 */
3、4位元組對齊(#pragma pack(4))
輸出結果：sizeof(struct test_t) = 16 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(4)
struct test_t {
int a; /* int型，長度4 = 4 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 4 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /*short型， 長度2 < 4 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 4 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 4) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 16 /*16%4=0*/
4、8位元組對齊(#pragma pack(8))
輸出結果：sizeof(struct test_t) = 16 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(8)
struct test_t {
int a; /* int型，長度4 < 8 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 8 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 < 8 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 8 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 8) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 16 /*16%4=0*/
5、16位元組對齊(#pragma pack(16))
輸出結果：sizeof(struct test_t) = 16 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(16)
struct test_t {
int a; /* int型，長度4 < 16 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* char型，長度1 < 16 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* short型，長度2 < 16 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d[6]; /* char型，長度1 < 16 按1對齊；起始offset=8 8%1=0；存放位置區間[8,D] */
};
#pragma pack()
成員總大小=14
2) 整體對齊
整體對齊系數 = min((max(int,short,char), 16) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 16 /*16%4=0*/ 8位元組和16位元組對齊試驗證明了「規則」的第3點：「當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果」。另外內存對齊是個很復雜的東西，讀者不妨把上述結構體中加個double型成員進去練習一下，上面所說的在有些時候也可能不正確。呵呵^_^
[注1]
什麼是「圓整」？
舉例說明：如上面的8位元組對齊中的「整體對齊」，整體大小=9 按 4 圓整 = 12
圓整的過程：從9開始每次加一，看是否能被4整除，這里9，10，11均不能被4整除，到12時可以，則圓整結束。
上面文字表述太不直觀了，鄙人給段代碼直觀的體現出來，代碼如下：
#pragma pack(4) /* n = 1, 2, 4, 8, 16 */struct test_t{int a;char b;short c;char d[6];}ttt;void print_hex_data(char *info, char *data, int len){int i;dbg_printf(%s: , info);for(i = 0; i < len; i++){dbg_printf(%02x , (unsigned char)data[i]);if (0 == ((i+1) % 32))dbg_printf( );}dbg_printf( );}int main(){ttt.a = 0x1a2a3a4a;ttt.b = 0x1b;ttt.c = 0x1c2c;char *s = 123456;memcpy(ttt.d, s, 6);print_hex_data(struct_data, (char *)&ttt, sizeof(struct test_t));return 0;}
#pragma pack(1)的結果：
4a 3a 2a 1a 1b 2c 1c 31 32 33 34 35 36
#pragma pack(2)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36
#pragma pack(4)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00
#pragma pack(8)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00
#pragma pack(16)的結果：
4a 3a 2a 1a 1b 00 2c 1c 31 32 33 34 35 36 00 00

Ⅱ linux內存分配默認是多少位元組對齊

VC和GCC默認的都是4位元組對齊，編程中可以使用#pragma pack(n)指定對齊模數。出現以上差異的原因在於，VC和GCC中對於double類型的對齊方式不同。
Win32平台下的微軟VC編譯器在默認情況下採用如下的對齊規則: 任何基本數據類型T的對齊模數就是T的大小，即sizeof(T)。比如對於double類型(8位元組)，就要求該類型數據的地址總是8的倍數，而char類型數據(1位元組)則可以從任何一個地址開始。
Linux下的GCC奉行的是另外一套規則:任何2位元組大小(包括單位元組嗎?)的數據類型(比如short)的對齊模數是2，而其它所有超過2位元組的數據類型(比如long,double)都以4為對齊模數。

復雜類型(如結構)的默認對齊方式是它最長的成員的對齊方式,這樣在成員是復雜類型時,可以最小化長度。
struct{char a；double b；}
在VC中，因為結構中存在double和char，按照最長數據類型對齊，char只佔1B，但是加上後面的double所佔空間超過8B，所以char獨佔8B；而double佔8B，一共16Byte。
在GCC中，double長度超過4位元組，按照4位元組對齊，原理同上，不過char佔4位元組，double占兩個4位元組，一共12Byte。

Ⅲ 怎麼查看c++編譯器是幾位元組對齊

給你個詳細的參考。。看了就應該可也明白了。。太亂的話。。直接看參考資料給的鏈接吧。。C/C++內存對齊一、什麼是位元組對齊,為什麼要對齊? 現代計算機中內存空間都是按照byte劃分的，從理論上講似乎對任何類型的變數的訪問可以從任何地址開始，但實際情況是在訪問特定類型變數的時候經常在特 定的內存地址訪問，這就需要各種類型數據按照一定的規則在空間上排列，而不是順序的一個接一個的排放，這就是對齊。 對齊的作用和原因：各個硬體平台對存儲空間的處理上有很大的不同。一些平台對某些特定類型的數據只能從某些特定地址開始存取。比如有些架構的CPU在訪問 一個沒有進行對齊的變數的時候會發生錯誤,那麼在這種架構下編程必須保證位元組對齊.其他平台可能沒有這種情況，但是最常見的是如果不按照適合其平台要求對 數據存放進行對齊，會在存取效率上帶來損失。比如有些平台每次讀都是從偶地址開始，如果一個int型（假設為32位系統）如果存放在偶地址開始的地方，那 么一個讀周期就可以讀出這32bit，而如果存放在奇地址開始的地方，就需要2個讀周期，並對兩次讀出的結果的高低位元組進行拼湊才能得到該32bit數 據。顯然在讀取效率上下降很多。二、請看下面的結構：struct MyStruct { double dda1; char dda; int type }; 對結構MyStruct採用sizeof會出現什麼結果呢？sizeof(MyStruct)為多少呢？也許你會這樣求： sizeof(MyStruct)=sizeof(double)+sizeof(char)+sizeof(int)=13 但是當在VC中測試上面結構的大小時，你會發現sizeof(MyStruct)為16。你知道為什麼在VC中會得出這樣一個結果嗎？ 其實，這是VC對變數存儲的一個特殊處理。為了提高CPU的存儲速度，VC對一些變數的起始地址做了「對齊」處理。在默認情況下，VC規定各成員變數存放的起始地址相對於結構的起始地址的偏移量必須為該變數的類型所佔用的位元組數的倍數。下面列出常用類型的對齊方式(vc6.0,32位系統)。 類型 對齊方式（變數存放的起始地址相對於結構的起始地址的偏移量） Char 偏移量必須為sizeof(char)即1的倍數 int 偏移把type

Ⅳ c++中內存是如何對齊的

有虛函數的話就有虛表，虛表保存虛函數地址，一個地址佔用的長度根據編譯器不同有可能不同，vs裡面是8個位元組，在devc++裡面是4個位元組。類和結構體的對齊方式相同，有兩條規則
1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。
2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行

下面是我收集的關於內存對齊的一篇很好的文章：

在最近的項目中，我們涉及到了「內存對齊」技術。對於大部分程序員來說，「內存對齊」對他們來說都應該是「透明的」。「內存對齊」應該是編譯器的 「管轄范圍」。編譯器為程序中的每個「數據單元」安排在適當的位置上。但是C語言的一個特點就是太靈活，太強大，它允許你干預「內存對齊」。如果你想了解更加底層的秘密，「內存對齊」對你就不應該再透明了。

一、內存對齊的原因
大部分的參考資料都是如是說的：
1、平台原因(移植原因)：不是所有的硬體平台都能訪問任意地址上的任意數據的；某些硬體平台只能在某些地址處取某些特定類型的數據，否則拋出硬體異常。
2、性能原因：數據結構(尤其是棧)應該盡可能地在自然邊界上對齊。原因在於，為了訪問未對齊的內存，處理器需要作兩次內存訪問；而對齊的內存訪問僅需要一次訪問。

二、對齊規則
每個特定平台上的編譯器都有自己的默認「對齊系數」(也叫對齊模數)。程序員可以通過預編譯命令#pragma pack(n)，n=1,2,4,8,16來改變這一系數，其中的n就是你要指定的「對齊系數」。

規則：
1、數據成員對齊規則：結構(struct)(或聯合(union))的數據成員，第一個數據成員放在offset為0的地方，以後每個數據成員的對齊按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。
2、結構(或聯合)的整體對齊規則：在數據成員完成各自對齊之後，結構(或聯合)本身也要進行對齊，對齊將按照#pragma pack指定的數值和結構(或聯合)最大數據成員長度中，比較小的那個進行。
3、結合1、2顆推斷：當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果。

三、試驗
我們通過一系列例子的詳細說明來證明這個規則吧!
我試驗用的編譯器包括GCC 3.4.2和VC6.0的C編譯器，平台為Windows XP + Sp2。

我們將用典型的struct對齊來說明。首先我們定義一個struct：
#pragma pack(n) /* n = 1, 2, 4, 8, 16 */
struct test_t {
int a;
char b;
short c;
char d;
};
#pragma pack(n)
首先我們首先確認在試驗平台上的各個類型的size，經驗證兩個編譯器的輸出均為：
sizeof(char) = 1
sizeof(short) = 2
sizeof(int) = 4

我們的試驗過程如下：通過#pragma pack(n)改變「對齊系數」，然後察看sizeof(struct test_t)的值。

1、1位元組對齊(#pragma pack(1))
輸出結果：sizeof(struct test_t) = 8 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(1)
struct test_t {
int a; /* 長度4 < 1 按1對齊；起始offset=0 0%1=0；存放位置區間[0,3] */
char b; /* 長度1 = 1 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* 長度2 > 1 按1對齊；起始offset=5 5%1=0；存放位置區間[5,6] */
char d; /* 長度1 = 1 按1對齊；起始offset=7 7%1=0；存放位置區間[7] */
};
#pragma pack()
成員總大小=8

2) 整體對齊
整體對齊系數 = min((max(int,short,char), 1) = 1
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 8 /* 8%1=0 */ [注1]

2、2位元組對齊(#pragma pack(2))
輸出結果：sizeof(struct test_t) = 10 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(2)
struct test_t {
int a; /* 長度4 > 2 按2對齊；起始offset=0 0%2=0；存放位置區間[0,3] */
char b; /* 長度1 < 2 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* 長度2 = 2 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d; /* 長度1 < 2 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */
};
#pragma pack()
成員總大小=9

2) 整體對齊
整體對齊系數 = min((max(int,short,char), 2) = 2
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 10 /* 10%2=0 */

3、4位元組對齊(#pragma pack(4))
輸出結果：sizeof(struct test_t) = 12 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(4)
struct test_t {
int a; /* 長度4 = 4 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* 長度1 < 4 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* 長度2 < 4 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d; /* 長度1 < 4 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */
};
#pragma pack()
成員總大小=9

2) 整體對齊
整體對齊系數 = min((max(int,short,char), 4) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 12 /* 12%4=0 */

4、8位元組對齊(#pragma pack(8))
輸出結果：sizeof(struct test_t) = 12 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(8)
struct test_t {
int a; /* 長度4 < 8 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* 長度1 < 8 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* 長度2 < 8 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d; /* 長度1 < 8 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */
};
#pragma pack()
成員總大小=9

2) 整體對齊
整體對齊系數 = min((max(int,short,char), 8) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 12 /* 12%4=0 */

5、16位元組對齊(#pragma pack(16))
輸出結果：sizeof(struct test_t) = 12 [兩個編譯器輸出一致]
分析過程：
1) 成員數據對齊
#pragma pack(16)
struct test_t {
int a; /* 長度4 < 16 按4對齊；起始offset=0 0%4=0；存放位置區間[0,3] */
char b; /* 長度1 < 16 按1對齊；起始offset=4 4%1=0；存放位置區間[4] */
short c; /* 長度2 < 16 按2對齊；起始offset=6 6%2=0；存放位置區間[6,7] */
char d; /* 長度1 < 16 按1對齊；起始offset=8 8%1=0；存放位置區間[8] */
};
#pragma pack()
成員總大小=9

2) 整體對齊
整體對齊系數 = min((max(int,short,char), 16) = 4
整體大小(size)=$(成員總大小) 按 $(整體對齊系數) 圓整 = 12 /* 12%4=0 */

四、結論
8位元組和16位元組對齊試驗證明了「規則」的第3點：「當#pragma pack的n值等於或超過所有數據成員長度的時候，這個n值的大小將不產生任何效果」。另外內存對齊是個很復雜的東西，上面所說的在有些時候也可能不正確。呵呵^_^

[注1]
什麼是「圓整」？
舉例說明：如上面的8位元組對齊中的「整體對齊」，整體大小=9 按 4 圓整 = 12
圓整的過程：從9開始每次加一，看是否能被4整除，這里9，10，11均不能被4整除，到12時可以，則圓整結束。

Ⅳ 內存對齊的規則

為了加快計算機的取數速度，編譯器默認對內存進行位元組對齊。對結構體（包括類）進行位元組對齊的原則是：
1）結構體變數的首地址能夠被其最寬基本類型成員的大小所整除；
2）結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal adding）；
3）結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之後加上填充位元組（trailing padding）。

struct SByte1
{
double d; // 偏移量0~7
char j; // 偏移量8
int a; // 偏移量12~15，由於9不能整除4，故先填充9~11
};
sizeof(SByte1); // = 16

struct SByte2
{
char j; // 偏移量0
double d; // 偏移量8~15，由於1不能整除8，故先填充1~7
int a; // 偏移量16~19
};
sizeof(SByte2); // = 24，為了湊成8的倍數，填充20~23

Ⅵ C語言位元組對齊問題

這個佔多少個位元組是不確定的！！！跟編譯器有關的！！
對於visual
c++來說：
int
4位元組
char
1位元組
float
4位元組
long
4位元組
double
8位元組
而對於gcc的編譯器來說
double佔12位元組！