---恢復內容開始---
-----------------------計算數據類型長度問題---------------------------------------
在c/c++學習中，我們不可避免的會接觸到數據存儲問題，而計算機中用sizeof函數來計算數據存儲需要的長度。
（1）基本數據類型
| 基本數據類型在不同編譯器中的大小 | |||
| 32位 | 64位 | 是否變化 | |
| bool | 1 | ||
| char | 1 | 1 | 沒有變化 |
| * | 4 | 8 | 變化 |
| short int | 2 | 2 | 沒有變化 |
| int | 4 | 4 | 沒有變化 |
| unsigned int | 4 | 4 | 沒有變化 |
| float | 4 | 4 | 沒有變化 |
| double | 8 | 8 | 沒有變化 |
| long | 4 | 8 | 變化 |
| unsigned long | 4 | 8 | 變化 |
| long long | 8 | 8 | 沒有變化 |
| string | 32 | ||
| void | 1 | 1 | 沒有變化 |
除了*與long隨操作系統子長變化而變化外。其它的都固定不變(32位和64相比)
bool 1個字節 char 1個字節 int 4個字節 float 4個字節 doubl 8個字節 long long 8個字節
oc中：
64位系統下（本機不是32位系統的沒法測試）：
nsstring 8位
nsinteger 8位（有符號的）
NSUInteger 8位（無符號的，沒有負數）
在oc中非常多變量其實是指針，所以64位系統下非常多都是8位的。
順便提下nsnumber，NSInteger是基礎類型，可是NSNumber是一個類。假設想要在NSMutableArray或者
NSMutableDictionary里存儲一個數值，直接用NSInteger是不行的。要先轉換成nsnumber類。
需要注意的是sizeof（void）在有點編譯器下結果為1，有的則編譯不通過。
（2）單獨函數所需要的存儲長度
此時注意的是函數返回類型，無論函數里面包含了什么內容，sizeof（函數（））返回大小為函數返回類型所需的大小。注意返回類型為void的情況。
int fun() {} sizeof(fun())=4；
（3）數組大小計算
數組的sizeof值等於數組所占用的內存字節數，如：
char a1[]= "abc";
inta2[3];
sizeof(a1 ); // 結果為4，字符末尾還存在一個NULL終止符
sizeof(a2 ); // 結果為3*4=12（依賴於int）
一些朋友剛開始時把sizeof當作了求數組元素的個數，現在，你應該知道這是不對的。那么應該怎么求數組元素的個數呢？
Easy，通常有下面兩種寫法：
int c1 =sizeof( a1 ) / sizeof( char ); // 總長度/單個元素的長度
int c2 =sizeof( a1 ) / sizeof( a1[0]); // 總長度/第一個元素的長度
寫到這里，提一問，下面的c3，c4值應該是多少呢？
*********************************************************
void foo3(char a3[3])
{
int c3 = sizeof( a3 ); // c3 ==4
}
void foo4(char a4[])
{
int c4 = sizeof( a4 ); // c4 ==4
}
*********************************************************
也許當你試圖回答c4的值時已經意識到c3答錯了，是的，c3!=3。
這里函數參數a3已不再是數組類型，而是蛻變成指針。相當於char* a3，為什么仔細想想就不難明白。
我們調用函數foo3時，程序會在棧上分配一個大小為3的數組嗎？不會！
數組是“傳址”的，調用者只需將實參的地址傳遞過去，所以a3自然為指針類型（char*），c3的值也就為4。
（4）結構體
結構體的問題涉及到內存對齊的問題，我們需要好好了解一下：
Struct s
{
char a;
int b;
double c;
}
Sizeof(s)此時的大小為16，而不是1+4+8=13，這就是傳說中的內存對齊問題。計算機組成原理教導我們，這樣有助於加快計算機的取數速度，否則就得多花指令周期了。為此，編譯器默認會對結構體進行處理（實際上其它地方的數據變量也是如此），讓寬度為2的基本數據類型（short等）都位於能被2整除的地址上，讓寬度為4的基本數據類型（int等）都位於能被4整除的地址上。以此類推，這樣，兩個數中間就可能需要加入填充字節，所以整個結構體的sizeof值就增長了。
但是內存對齊到底是怎么一回事我們接下來慢慢了解：
字節對齊的細節和編譯器實現相關，但一般而言，滿足三個准則：
1) 結構體變量的首地址能夠被其最寬基本類型成員的大小所整除；
2) 結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充字節（internal adding）；
3) 結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之后加上填充字節（trailing padding）。
結構體大小的計算方法和步驟：
i. 將結構體內所有數據成員的長度值相加，記為 sum_a ；
ii. 將各數據成員為了內存對齊，按各自對齊模數而填充的字節數累加到sum_a上，記為sum_b。
對齊模數是 #pragma pack 指定的數值與該數據成員自身長度相比較得到的數值較小者。該數據相對起始位置應該是對齊模數的整數倍。
iii. 將和 sum_b 向結構體模數對齊。
該模數則是 #pragma pack 指定的數值與結構體內最大的基本數據類型成員長度相比較得到的數值較小者。結構體的長度應該是該模數的整數倍。
計算結構體所需內存大小需要分兩種情況：
1） 在沒有#pragmapack宏的情況下：
例子1：
內存分配狀態為：
對於結構體的第一個成員 a，起始位置為0x…38 （也為 4 的倍數），所占內存為 0x…38 ~ 0x…3b，共占4個字節；
對於結構體的第二個成員 b，自身長度為1，對齊模數也為1，所以內存分配可以緊接着a的結尾位置 0x…3b，所以起始位置為 0x…3c，共占1個字節；
對於結構體的第三個成員 c，自身長度為2，對齊模數也為2，所以起始位置距離a 的起始位置應該是2的倍數，所以 0x…3d處只距離5，不符合要求，所以空着，繼續往下找，而在 0x…3e處滿足要求，所以可以作為c的起始位置，共占2個字節；
此時3個成員及其中間空着的位置所占內存單元總和為8，而結構體內最大的基本數據成員是 a，其長度為4，所以結構體模數為 4，而8是4的倍數，滿足要求，故不再加內存。
例子2：
與例子1相比，三個類型的聲明順序變了：
內存分配狀態為：
要注意的是，對 a而言，對齊模數為 4，所以當 b的起始位置在0x7f…830之后，0x7f…831、0x7f…832、0x7f…833的位置距離起始位置0x7f…830分別是1，2，3，都不是 4 的倍數，所以那三個位置都空着，直到0x7f…834才滿足要求，所以作為 a 的起始位置。當最后一個成員 c 占的內存末尾在0x7f…839時，所有數據成員及其之間的空位所占內存單元總和為10，而結構體模數為4，10不是4的倍數，所以要擴大到12才滿足要求，此時又多了2個空位置，就是0x7f…83a和0x7f…83b。
例子3：
當結構體中有數組時：
內存分配狀態為：
亦即相同類型數據的數組之間多分配的空間會被相鄰數組的元素所占用。
2） 在有#pragmapack宏的情況下：
方法類似，只是模數可能會按上面說的規則而有所變化。
內存分配狀態為：
注意，當沒有#pragma pack(2)時，成員a要確定自身的q起始位置，是以自身的長度4為對齊模數，但有了#pragma pack(2)，則將括號里的2與a的長度4比較，2為較小者，所以以2為a的對齊模數，即地址從0x7f…839往下找到0x7f…83a時，已經距離結構體的起始位置0x7f…838為2，是2的倍數，滿足要求（雖然不是4的倍數），可以作為a的起始位置。而最后，所有數據成員及其之間的空位所占內存單元總和為8，因為2和4（結構體中最大的數據成員長度）的較小者為2，而8是2的倍數，所以剛好滿足要求，不用在分配空位置，所以結構體總長度即為8。
（5）類的存儲大小計算
類的sizeof值等於類中成員變量所占用的內存字節數。如：
****************************************************************
class A
{
public:
int b;
float c;
char d;
};
int main(void)
{
A object;
cout << "sizeof(object)is " << sizeof(object) << endl;
return 0 ;
}
***************************************************************
輸出結果為12（我的機器上sizeof(float)值為4，字節對其前面已經講過）。
注意：
1、類的對象（即實例）所占用的空間大小只取決於該對象中數據成員所占用的空間，而與成員函數無關。函數的代碼是存儲在對象空間之外的。
2、不論成員函數在類內定義還是在類外定義，成員函數的代碼段都用同一種方式存儲，即都不占用對象的存儲空間。
3、不論是否用inline（內置）聲明函數，成員函數的代碼段都不占用對象的存儲空間。用inline聲明的作用是在調用該函數時，將函數的代碼段復制插入到函數調用點，若不用inline聲明，在調用該函數時，流程轉去函數代碼段的入口地址，在執行完該函數代碼段后，流程返回函數調用點。inline與成員函數是否占用對象的存儲空間無關，他們不屬於同一個問題，不應該搞混。
不過需要注意的是，如果類中存在靜態成員變量，結果又會是什么樣子呢？
***************************************************************
class A
{
public:
static int a;
int b;
float c;
char d;
};
int main()
{
A object;
cout << "sizeof(object) is " << sizeof(object)<< endl;
return 0 ;
}
**************************************************************
16？不對。結果仍然是12.
因為在程序編譯期間，就已經為static變量在靜態存儲區域分配了內存空間，並且這塊內存在程序的整個運行期間都存在。
而每次聲明了類A的一個對象的時候，為該對象在堆上，根據對象的大小分配內存。
如果類A中包含成員函數，那么又會是怎樣的情況呢？看下面的例子
*************************************************************
class A
{
public:
static int a;
int b;
float c;
char d;
int add(int x,int y)
{
return x+y;
}
};
int main()
{
A object;
cout << "sizeof(object)is " << sizeof(object) << endl;
b = object.add(3,4);
cout << "sizeof(object)is " << sizeof(object) << endl;
return 0 ;
}
***************************************************************
結果仍為12。
因為只有非靜態類成員變量在新生成一個object的時候才需要自己的副本。
所以每個非靜態成員變量在生成新object需要內存，而function是不需要的。
注：C++中的多態和虛繼承也是非常重要的東西，不過比較復雜，編譯器不同，細節也有所不同。
/////////////////////////////////////////////////////////////////////////////////////////////////
如下一段代碼：
#pragma pack(4)
class TestB
{
public:
int aa;
char a;
short b;
char c;
};
int nSize = sizeof(TestB);
這里nSize結果為12，在預料之中。
現在去掉第一個成員變量為如下代碼：
#pragma pack(4)
class TestC
{
public:
char a;
short b;
char c;
};
int nSize = sizeof(TestC);
按照正常的填充方式nSize的結果應該是8，為什么結果顯示nSize為6呢？
事實上，很多人對#pragma pack的理解是錯誤的。
#pragma pack規定的對齊長度，實際使用的規則是：
結構，聯合，或者類的數據成員，第一個放在偏移為0的地方，以后每個數據成員的對齊，按照#pragma pack指定的數值和這個數據成員自身長度中，比較小的那個進行。也就是說，當#pragma pack的值等於或超過所有數據成員長度的時候，這個值的大小將不產生任何效果。而結構整體的對齊，則按照結構體中最大的數據成員 和 #pragmapack指定值之間，較小的那個進行。
具體解釋
#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字節
類之間的對齊，是按照類內部最大的成員的長度，和#pragma pack規定的值之中較小的一個對齊的。
所以這個例子中，類之間對齊的長度是min(sizeof(int),4)，也就是4。
9按照4字節圓整的結果是12，所以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]的位置。
};
//可以看出，上面的位置完全沒有變化，只是類之間改為按2字節對齊，9按2圓整的結果是10。所以 sizeof(TestB)是10。
最后看原貼：
現在去掉第一個成員變量為如下代碼：
#pragma pack(4)
class TestC
{
public:
char a;//第一個成員，放在[0]偏移的位置，
short b;//第二個成員，自身長2，#pragmapack(4)，取2，按2字節對齊，所以放在偏移[2,3]的位置。
char c;//第三個，自身長為1，放在[4]的位置。
};
//整個類的大小是5字節，按照min(sizeof(short),4)字節對齊，也就是2字節對齊，結果
是6所以sizeof(TestC)是6。
常見sizeof面試片段：
面試官：定義一個空的類型，里面沒有任何成員變量和成員函數。對該類型求sizeof，得到的結果是多少？
應聘者：答案是1.
面試官：為什么不是0？
應聘者：空類型的實例中不包含任何信息，本來求sizeof應該是0，但是我們聲明該類的實例的時候，他必須在內存中占有一定的空間，否則無法使用這些實例。至於占用多少內存由編譯器決定。在Visual Studio中，每個空類型的實例占用1字節的空間。
面試官：如果在該類型中添加一個構造函數和析構函數，再對該類型求sizeof，得到的結果又是多少？
應聘者：和前面一樣，還是1.調用構造函數和析構函數只需要知道函數的地址即可，而這些函數的地址只與類型相關，而與類型的實例無關，編譯器也不因為這兩個函數而在實例內添加任何額外的信息。
面試官：那如果析構函數標記為虛函數呢？
應聘者：C++的編譯器一旦發現一個類型中有虛函數，就會為該類型生成虛函數表，並在該類型的每一個實例中添加一個指向虛函數表的指針。在32位的機器上，一個指針占4字節，因此求sizeof得到4；在64位的機器上，一個指針占8字節，因此求sizeof得到8.