sizeof編譯

1. C語言中 sizeof 運算的值是在編譯時還是運

一、在 Pascal 語言中，sizeof() 是一種內存容量度量函數，功能是返回一個變數或者類型的大小（以位元組為單位）；在 C 語言中，sizeof() 是一個判斷數據類型或者表達式長度的運算符。在Pascal 語言與C語言中，對 sizeof() 的處理都是在編譯階段進行。

二、C語言中

1. 判斷數據類型長度符的關鍵字

2. 用法

   sizeof(類型說明符，數組名或表達式);
   或sizeof (變數名);

3. 定義

4. sizeof是C/C++中的一個操作符（operator），簡單的說其作用就是返回一個對象或者類型所佔的內存位元組數。

   MSDN上的解釋為：

   The sizeof keyword gives the amount of storage, in bytes, associated with a variable or a type(including aggregate types). This keyword returns a value of type size_t.

   其返回值類型為size_t，在頭文件stddef.h中定義。這是一個依賴於編譯系統的值，一般定義為

5. typedefunsignedintsize_t;

6. 在C99及以上標准中，sizeof(char)、sizeof(int)、sizeof(long)、sizeof(long long)、sizeof(float)、sizeof(double)、sizeof(long double)的值分別是1，4，4，8，4，8，16。[1]

7. 語法

   sizeof有三種語法形式，如下：

8. sizeof(object);//sizeof(對象);
   sizeof(type_name);//sizeof(類型);
   sizeofobject;//sizeof對象;

   所以，

9. inti;
   sizeof(i);//ok
   sizeofi;//ok
   sizeof(int);//ok
   sizeofint;//error

   既然寫法3可以用寫法1代替，為求形式統一以及減少我們大腦的負擔，第3種寫法，忘掉它吧！實際上，sizeof計算對象的大小也是轉換成對對象類型的計算，也就是說，同種類型的不同對象其sizeof值都是一致的。這里，對象可以進一步延伸至表達式，即sizeof可以對一個表達式求值，編譯器根據表達式的最終結果類型來確定大小，一般不會對表達式進行計算。如：

10. sizeof(2);//2的類型為int，所以等價於sizeof(int);
    sizeof(2+3.14);//3.14的類型為double，2也會被提升成double類型，所以等價於sizeof(double);

11. sizeof也可以對一個函數調用求值，其結果是函數返回類型的大小，函數並不會被調用，我們來看一個完整的例子：

12. charfoo()
    {
    printf("foo()hasbeencalled.
    ");
    return'a';
    }
    intmain()
    {
    size_tsz=sizeof(foo());
    //foo()的返回值類型為char，所以sz=sizeof(char)，foo()並不會被調用
    printf("sizeof(foo())=%d
    ",sz);
    }

13. C99標准規定，函數、不能確定類型的表達式以及位域（bit-field）成員不能被計算sizeof值，即下面這些寫法都是錯誤的：[1]

14. sizeof(foo);//error
    voidfoo2(){}
    sizeof(foo2());//error
    structS
    {
    unsignedintf1:1;
    unsignedintf2:5;
    unsignedintf3:12;
    };
    sizeof(S.f1);//error

15. sizeof的常量性

    sizeof的計算發生在編譯時刻，所以它可以被當作常量表達式使用，如：

    charary[sizeof(int)*10];//ok
    

16. 最新的C99標准規定sizeof也可以在運行時刻進行計算，如下面的程序在Dev-C++中可以正確執行：[1]

17. intn;
    n=10;//n動態賦值
    charary[n];//C99也支持數組的動態定義
    printf("%d
    ",sizeof(ary));//ok.輸出10

18. 但在沒有完全實現C99標準的編譯器中就行不通了，上面的代碼在VC6中就通不過編譯。所以我們最好還是認為sizeof是在編譯期執行的，這樣不會帶來錯誤，讓程序的可移植性強些。

    基本數據類型的sizeof

    這里的基本數據類型指short、int、long、float、double這樣的簡單內置數據類型，由於它們都是和系統相關的，所以在不同的系統下取值可能不同，這務必引起我們的注意，盡量不要在這方面給自己程序的移植造成麻煩。

    一般的，在32位編譯環境中，sizeof(int)的取值為4。

19. 指針變數的sizeof

    學過數據結構的你應該知道指針是一個很重要的概念，它記錄了另一個對象的地址。既然是來存放地址的，那麼它當然等於計算機內部地址匯流排的寬度。所以在32位計算機中，一個指針變數的返回值必定是4（注意結果是以位元組為單位），但是，在64位系統中指針變數的sizeof結果為8。

20. char*pc="abc";
    int*pi;
    string*ps;
    char**ppc=&pc;
    void(*pf)();//函數指針
    sizeof(pc);//結果為4
    sizeof(pi);//結果為4
    sizeof(ps);//結果為4
    sizeof(ppc);//結果為4
    sizeof(pf);//結果為4

21. 指針變數的sizeof值與指針所指的對象沒有任何關系，正是由於所有的指針變數所佔內存大小相等，所以MFC消息處理函數使用兩個參數WPARAM、LPARAM就能傳遞各種復雜的消息結構（使用指向結構體的指針）。

    數組的sizeof

    數組的sizeof值等於數組所佔用的內存位元組數，如：

    char a1[] = "abc"; int a2[3]; sizeof( a1 ); // 結果為4，字元末尾還存在一個NULL終止符 sizeof( a2 ); // 結果為3*4=12（依賴於int）

    一些朋友剛開始時把sizeof當作了求數組元素的個數，如今你應該知道這是不對的，那麼應該怎麼求數組元素的個數呢Easy，通常有下面兩種寫法：

22. intc1=sizeof(a1)/sizeof(char);//總長度/單個元素的長度char型
    intc2=sizeof(a2)/sizeof(a2[0]);//總長度/第一個元素的長度int型

    寫到這里，提一問，下面的c3，c4值應該是多少呢

23. voidfoo3(chara3[3])
    {
    intc3=sizeof(a3);//c3==
    }
    voidfoo4(chara4[])
    {
    intc4=sizeof(a4);//c4==
    }

    也許當你試圖回答c4的值時已經意識到c3答錯了，是的，c3!=3。這里函數參數a3已不再是數組類型，而是蛻變成指針，相當於char* a3，為什麼仔細想想就不難明白，我們調用函數foo3時，程序會在棧上分配一個大小為3的數組嗎不會！數組是「傳址」的，調用者只需將實參的地址傳遞過去，所以a3自然為指針類型（char*），c3的值也就為4。

    結構體的sizeof

    這是初學者問得最多的一個問題，所以這里有必要多費點筆墨。讓我們先看一個結構體：

    structS1{charc;inti;};
    

    問sizeof(s1)等於多少聰明的你開始思考了，char佔1個位元組，int佔4個位元組，那麼加起來就應該是5。是這樣嗎？你在你機器上試過了嗎？也許你是對的，但很可能你是錯的！VC6中按默認設置得到的結果為8。
    

    我們來好好琢磨一下sizeof的定義——sizeof的結果等於對象或者類型所佔的內存位元組數，好吧，那就讓我們來看看S1的內存分配情況：

    S1 s1={'a',0xFFFFFFFF};

    定義上面的變數後，加上斷點，運行程序，觀察s1所在的內存，你發現了什麼

    以我的VC6.0為例，s1的地址為0x0012FF78，其數據內容如下：

    0012FF78: 61 CC CC CC FF FF FF FF

    發現了什麼怎麼中間夾雜了3個位元組的CC看看MSDN上的說明：

    When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.

    原來如此，這就是傳說中的位元組對齊啊！一個重要的話題出現了。

    為什麼需要位元組對齊計算機組成原理教導我們這樣有助於加快計算機的取數速度，否則就得多花指令周期了。為此，編譯器默認會對結構體進行處理（實際上其它地方的數據變數也是如此），讓寬度為2的基本數據類型（short等）都位於能被2整除的地址上，讓寬度為4的基本數據類型（int等）都位於能被4整除的地址上，以此類推。這樣，兩個數中間就可能需要加入填充位元組，所以整個結構體的sizeof值就增長了。

    讓我們交換一下S1中char與int的位置：

    struct S2{inti;charc;};

    看看sizeof(S2)的結果為多少，怎麼還是8再看看內存，原來成員c後面仍然有3個填充位元組，這又是為什麼啊別著急，下面總結規律。

    位元組對齊的細節和編譯器實現相關，但一般而言，滿足三個准則：

24. 1)結構體變數的首地址能夠被其最寬基本類型成員的大小所整除；

    2)結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal padding）；

    3)結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之後加上填充位元組（trailing padding）。

    對於上面的准則，有幾點需要說明：

    1) 前面不是說結構體成員的地址是其大小的整數倍，怎麼又說到偏移量了呢因為有了第1點存在，所以我們就可以只考慮成員的偏移量，這樣思考起來簡單。想想為什麼。

    結構體某個成員相對於結構體首地址的偏移量可以通過宏offsetof()來獲得，這個宏也在stddef.h中定義，如下：

    #define offsetof(s,m)(size_t)&(((s*)0)->m)

    例如，想要獲得S2中c的偏移量，方法為

    size_tpos=offsetof(S2,c);//pos等於4

    2) 基本類型是指前面提到的像char、short、int、float、double這樣的內置數據類型，這里所說的「數據寬度」就是指其sizeof的大小。由於結構體的成員可以是復合類型，比如另外一個結構體，所以在尋找最寬基本類型成員時，應當包括復合類型成員的子成員，而不是把復合成員看成是一個整體。但在確定復合類型成員的偏移位置時則是將復合類型作為整體看待。

    這里敘述起來有點拗口，思考起來也有點撓頭，還是讓我們看看例子吧（具體數值仍以VC6為例，以後不再說明）：

    struct S3{charc1;S1s;charc2;};

    S1的最寬簡單成員的類型為int，S3在考慮最寬簡單類型成員時是將S1「打散」看的，所以S3的最寬簡單類型為int，這樣，通過S3定義的變數，其存儲空間首地址需要被4整除，整個sizeof(S3)的值也應該被4整除。

    c1的偏移量為0，s的偏移量呢這時s是一個整體，它作為結構體變數也滿足前面三個准則，所以其大小為8，偏移量為4，c1與s之間便需要3個填充位元組，而c2與s之間就不需要了，所以c2的偏移量為12，算上c2的大小為13，13是不能被4整除的，這樣末尾還得補上3個填充位元組。最後得到sizeof(S3)的值為16。

    通過上面的敘述，我們可以得到一個公式：

    結構體的大小等於最後一個成員的偏移量加上其大小再加上末尾的填充位元組數目，即：

25. sizeof(struct)=offsetof(lastitem)+sizeof(lastitem)+sizeof(trailingpadding);

    到這里，朋友們應該對結構體的sizeof有了一個全新的認識，但不要高興得太早，有一個影響sizeof的重要參量還未被提及，那便是編譯器的pack指令。它是用來調整結構體對齊方式的，不同編譯器名稱和用法略有不同，VC6中通過#pragmapack實現，也可以直接修改/Zp編譯開關。#pragma pack的基本用法為：

    #pragmapack(n)，n為位元組對齊數，其取值為1、2、4、8、16，默認是8，如果這個值比結構體成員的sizeof值小，那麼，該成員的偏移量應該以此值為准，即是說，結構體成員的偏移量應該取二者的最小值，

    公式如下：

    offsetof(item)=min(n,sizeof(item))

26. 再看示例：

27. #pragmapack(push)//將當前pack設置壓棧保存
    #pragmapack(2)//必須在結構體定義之前使用
    structS1{charc;inti;};
    structS3{charc1;S1s;charc2;};
    #pragmapack(pop)//恢復先前的pack設置

    計算sizeof(S1)時，min(2, sizeof(i))的值為2，所以i的偏移量為2，加上sizeof(i)等於6，能夠被2整除，所以整個S1的大小為6。

    同樣，對於sizeof(S3)，s的偏移量為2，c2的偏移量為8，加上sizeof(c2)等於9，不能被2整除，添加一個填充位元組，所以sizeof(S3)等於10。

    如今，朋友們可以輕松的出一口氣了，:)

    還有一點要注意，「空結構體」（不含數據成員）的大小不為0，而是1。試想一個「不佔空間」的變數如何被取地址、兩個不同的「空結構體」變數又如何得以區分呢於是，「空結構體」變數也得被存儲，這樣編譯器也就只能為其分配一個位元組的空間用於佔位了。如下：

    struct S5 { }; sizeof( S5 ); // 結果為1含位域結構體的sizeof

    前面已經說過，位域成員不能單獨被取sizeof值，我們這里要討論的是含有位域的結構體的sizeof，只是考慮到其特殊性而將其專門列了出來。

    C99規定int、unsigned int和bool可以作為位域類型，但編譯器幾乎都對此作了擴展，允許其它類型類型的存在。使用位域的主要目的是壓縮存儲，其大致規則為：

28. 1) 如果相鄰位域欄位的類型相同，且其位寬之和小於類型的sizeof大小，則後面的欄位將緊鄰前一個欄位存儲，直到不能容納為止；

    2) 如果相鄰位域欄位的類型相同，但其位寬之和大於類型的sizeof大小，則後面的欄位將從新的存儲單元開始，其偏移量為其類型大小的整數倍；

    3) 如果相鄰的位域欄位的類型不同，則各編譯器的具體實現有差異，VC6採取不壓縮方式，Dev-C++採取壓縮方式；

    4) 如果位域欄位之間穿插著非位域欄位，則不進行壓縮；

    5) 整個結構體的總大小為最寬基本類型成員大小的整數倍。

29. 還是讓我們來看看例子。

    示例1：

    struct BF1{charf1:3;charf2:4;charf3:5;};

    其內存布局為：

30. |_f1__|__f2__|_|____f3___|____|
    

31. |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|

32. 0 3 7 8 1316
    

    位域類型為char，第1個位元組僅能容納下f1和f2，所以f2被壓縮到第1個位元組中，而f3隻

    能從下一個位元組開始。因此sizeof(BF1)的結果為2。

    示例2：

    structBF2{charf1:3;shortf2:4;charf3:5;};

    由於相鄰位域類型不同，在VC6中其sizeof為3，在Dev-C++中為2。

    示例3：

    structBF3{charf1:3;charf2;charf3:5;};

    非位域欄位穿插在其中，不會產生壓縮，在VC6和Dev-C++中得到的大小均為3。

    9.聯合體的sizeof

    結構體在內存組織上是順序式的，聯合體則是重疊式，各成員共享一段內存，所以整個聯合體的sizeof也就是每個成員sizeof的最大值。結構體的成員也可以是復合類型，這里，復合類型成員是被作為整體考慮的。

    所以，下面例子中，U的sizeof值等於sizeof(s)。

33. unionU
    {
    inti;
    charc;
    S1s;
    };

sizeof還可以用函數做參數，比如：

shortf();
printf("%d
",sizeof(f()));

輸出的結果是sizeof(short)，即2。

數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。

大部分編譯程序在編譯的時候就把sizeof計算過了是類型或是變數的長度這就是sizeof(x)可以用來定義數組維數的原因

charstr[20]="0123456789";
inta=strlen(str);//a=10;
intb=sizeof(str);//而b=20;

7.sizeof後如果是類型必須加括弧，如果是變數名可以不加括弧。這是因為sizeof是個操作符不是個函數。

8.當適用於一個結構類型時或變數， sizeof 返回實際的大小，當適用於靜態的空間數組， sizeof 歸還全部數組的尺寸。

sizeof 操作符不能返回被動態分派的數組或外部數組的尺寸

9.數組作為參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，

fun(char[8])fun(char[])

都等價於 fun(char *)

1. 特別注意：

2. 1.sizeof是運算符，strlen是函數，具體如下：

3. sizeof

4. strlen

5. 頭文件：stddef.h格式：1) sizeof( object ); // sizeof( 對象 );

6. 2) sizeof( type_name ); // sizeof( 類型 );

7. 3) sizeof object; // sizeof 對象

8. 功能：一個對象或者類型所佔的內存位元組數;

9. 說明：sizeof操作符的結果類型是size_t，typedef unsigned int size_t;

10. 原型：extern unsigned int strlen(char *s);頭文件：string.h

11. 格式：strlen (字元數組名)

12. 功能：計算字元串s的(unsigned int型)長度,不包括''在內

13. 說明：返回s的長度，不包括結束符NULL。

14. 2.strlen只能用char*做參數，且必須是以''''結尾的，而sizeof可用類型做參數，還可用函數做參數，如：

    int sum();

    printf("%d ",sizeof(sum()));//輸出的結果是sizeof(int)，即4。

    數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。

    大部分編譯程序,sizeof在編譯時確定，因此sizeof(x)可以用來定義數組維數；而strlen要在運行時才能計算出來，用來計算字元串的長度，而不是類型占內存的大小；

    char str[20]="0123456789";

    int len1=strlen(str);//len1=10;

    int len2=sizeof(str);//len2=20;

15. sizeof後，若為類型必須加括弧，若為變數名可以不加括弧。這是因為sizeof是個操作符不是個函數。
    當適用於一個結構類型時或變數， sizeof 返回實際的大小；當適用一靜態地空間數組，sizeof 歸還全部數組的尺寸。
    sizeof 操作符不能返回動態地被分派了的數組或外部的數組的尺寸；
    數組作為參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，
    如：

    fun(char[8])

    fun(char[])

16. 都等價於 fun( char * )
    在C++里參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小，如果想在函數內知道數組的大小， 需要這樣做：
    進入函數後用memcpy拷貝出來，長度由另一個形參傳進去

17. fun(unsigedchar*p1,intlen)
    {
    unsignedchar*buf=newunsignedchar[len+1];
    memcpy(buf,p1,len);
    }

18. 常在用到 sizeof 和 strlen 的時候，通常是計算字元串數組的長度，如果是對指針，結果則會不一樣的：
    char* str = "abacd";
    sizeof(str) //結果 4 --->str是指向字元串常量的字元指針，sizeof 獲得的是一個指針所佔的空間,應該是長整型的，所以是4；
    sizeof(*str) //結果 1 --->*str是第一個字元，其實就是字元串的第一位'a' 所佔的內存空間，是char類型的，佔了 1 位；
    strlen(str)= 5 //--->若要獲得這個字元串的長度，則一定要使用 strlen

19. 看了上面的詳細解釋，發現兩者的使用還是有區別的，從這個例子可以看得很清楚：

    char str[20]="0123456789";

    int a=strlen(str); //a=10; >>>> strlen 計算字元串的長度，以結束符 0x00 為字元串結束。

20. int b=sizeof(str); //而b=20; >>>> sizeof 計算的則是分配的數組str[20] 所佔的內存空間的大小，不受裡面存儲的內容改變。上面是對靜態數組處理的結果，如果是對指針，結果就不一樣了

    char* ss = "0123456789";sizeof(ss) 結果 4 ===》ss是指向字元串常量的字元指針，sizeof 獲得的是一個指針的之所佔的空間,應該是長整型的，所以是4

    sizeof(*ss) 結果 1 ===》*ss是第一個字元其實就是獲得了字元串的第一位'0' 所佔的內存空間，是char類型的，佔了 1 個位元組

    strlen(ss)= 10 >>>> 如果要獲得這個字元串的長度，則一定要使用 strlen

    sizeof返回對象所佔用的位元組大小. //正確

    strlen返回字元個數. //正確

21. 在使用sizeof時，有一個很特別的情況，就是數組名到指針蛻變，

    charArray[3]={'0'};

    sizeof(Array)==3;

    char*p=Array;

    strlen(p)==1;//sizeof(p)結果為4

    在傳遞一個數組名到一個函數中時，它會完全退化為一個指針
    

    大部分編譯程序 在編譯的時候就把sizeof計算過了 是類型或是變數的長度

    這就是sizeof(x)可以用來定義數組維數的原因

22. charstr[20]="0123456789";
    inta=strlen(str);//a=10;
    intb=sizeof(str);//而b=20;
    charss[]="0123456789";
    sizeof(ss)結果11===》ss是數組，計算到位置，因此是10+1
    sizeof(*ss)結果1===》*ss是第一個字元
    charss[100]="0123456789";
    sizeof(ss)結果是100===》ss表示在內存中的大小100×1
    strlen(ss)結果是10===》strlen是個函數內部實現是用一個循環計算到為止之前
    intss[100]="0123456789";
    sizeof(ss)結果400===》ss表示在內存中的大小100×4
    strlen(ss)錯誤===》strlen的參數只能是char*且必須是以''結尾的
    charq[]="abc";
    charp[]="a
    ";
    sizeof(q),sizeof(p),strlen(q),strlen(p);

    結果是 4 3 3 2

23. 第三個例子

    charszPath[MAX_PATH]
    

    如果在函數內這樣定義，那麼sizeof(szPath)將會是MAX_PATH，但是將szPath作為虛參聲明時

    （voidfun(charszPath[MAX_PATH]))

    sizeof(szPath) 卻會是4(指針大小)

    還有一位網友的說明也很好：

    其實理解 sizeof 只需要抓住一個要點：棧

    程序存儲分布有三個區域：棧、靜態和動態。能夠從代碼直接操作的對象，包括任何類型的變數、指針，都是在棧上的；動態和靜態存儲區是靠棧上的所有指針間接操作的。 sizeof 操作符，計算的是對象在棧上的投影體積；記住這個就很多東西都很清楚了。

24. charconst*static_string="Hello";
    //sizeof(static_string)是sizeof一個指針，所以在32bitsystem是4
    charstack_string[]="Hello";
    //sizeof(stack_string)是sizeof一個數組，所以是6*sizeof(char)
    char*string=newchar[6];
    strncpy(string,"Hello",6");
    //sizeof(string)是sizeof一個指針，所以還是4。
    //和第一個不同的是，這個指針指向了動態存儲區而不是靜態存儲區。

    不管指針指向的內容在什麼地方，sizeof 得到的都是指針的棧大小

    C++ 中對引用的處理比較特殊；sizeof 一個引用得到的結果是 sizeof 一個被引用的對象的大小；所以

25. structtest
    {
    inta,b,c,d,e,f,g,h;
    };
    intmain()
    {
    test&r=*newtest;
    cout<<sizeof(test)<<endl;//32
    cout<<sizeofr<<endl;//也是32
    system("PAUSE");
    }

    r 引用的是整個的 test 對象而不是指向 test 的指針，所以 sizeof r 的結果和 sizeof test 完全相同。