C中sizeof用法

一、sizeof的概念

  sizeof是C語言的一種單目操作符，如C語言的其他操作符++、--等。它並不是函數。sizeof操作符以字節形式給出了其操作數的存儲大小。操作數可以是一個表達式或括在括號內的類型名。操作數的存儲大小由操作數的類型決定。

二、sizeof的使用方法

1、用於數據類型

     sizeof使用形式：sizeof（type）
數據類型必須用括號括住。如sizeof（int）。

2、用於變量

sizeof使用形式：sizeof（var_name）或sizeof var_name
變量名可以不用括號括住。如sizeof (var_name)，sizeof var_name等都是正確形式。帶括號的用法更普遍，大多數程序員采用這種形式。
注意：sizeof操作符不能用於函數類型，不完全類型或位字段。不完全類型指具有未知存儲大小的數據類型，如未知存儲大小的數組類型、未知內容的結構或聯合類型、void類型等。sizeof(void)都不是正確形式。

三、sizeof的常見結果

    sizeof操作符的結果類型是size_t，它在頭文件中typedef為unsigned int類型。該類型保證能容納實現所建立的最大對象的字節大小。
1、若操作數具有類型char、unsigned char或signed char，其結果等於1。ANSI C正式規定字符類型為1字節。例如int類型在16位系統中占2個字節，在32位系統中占4個字節。
2、int、unsigned int 、short int、unsigned short 、long int 、unsigned long 、float、double、long double類型的sizeof 在ANSI C中沒有具體規定，大小依賴於實現，一般可能分別為2、2、2、2、4、4、4、8、10。
3、當操作數是指針時，sizeof依賴於編譯器。例如Microsoft C/C++7.0中，near類指針字節數為2，far、huge類指針字節數為4。一般Unix的指針字節數為4。
4、當操作數具有數組類型時，其結果是數組的總字節數。
5、聯合類型操作數的sizeof是其最大字節成員的字節數。結構類型操作數的sizeof是這種類型對象的總字節數，包括任何填充在內。
讓我們看如下結構：
struct {char b; double x;} a;
在某些機器上sizeof（a）=12，而一般sizeof（char）+ sizeof（double）=9。這是因為編譯器在考慮對齊問題時，在結構中插入空位以控制各成員對象的地址對齊。如double類型的結構成員x要放在被4整除的地址。具體分析見第五節。

6、unsigned影響的只是最高位bit的正負，數據長度是不會被改變的，即sizeof(unsigned int) = sizeof(int)

7、自定義類型的sizeof取值等用於它的類型原型。如typeof short TT;sizeof(TT) = sizeof(short)。

8、參數為結構或類。Sizeof應用在類和結構的處理情況是相同的。但有兩點需要注意。

第一、結構或者類中的靜態成員不對結構或者類的大小產生影響，因為靜態變量的存儲位置與結構或者類的實例地址無關。 第二、沒有成員變量的結構或類的大小為1，因為必須保證結構或類的每一個實例在內存中都有唯一的地址。
舉例說明如下：

Class Test{int a;static double c};//sizeof(Test)=4.
Test *s;//sizeof(s)=4,s為一個指針。
Class test1{ };//sizeof(test1)=1;

四、Sizeof與Strlen的區別

1、sizeof操作符的結果類型是size_t，它在頭文件中typedef為unsigned int類型。該類型保證能容納實現所建立的最大對象的字節大小。
2、sizeof是算符，strlen是函數。
3、sizeof可以用類型做參數，strlen只能用char*做參數，且必須是以''\0''結尾的。
sizeof還可以用函數做參數，比如：

short f();
printf("%d\n", sizeof(f()));

輸出的結果是sizeof(short)，即2。因為f的返回類型為short，所以相當於求sizeof(short)。
4、數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。
5、大部分編譯程序在編譯的時候就把sizeof計算過了，是類型或是變量的長度這就是sizeof(x)可以用來定義數組維數的原因。

char str[20]="0123456789";
int a=strlen(str); //a=10;
int b=sizeof(str); //而b=20;

6、strlen的結果要在運行的時候才能計算出來，時用來計算字符串的長度，不是類型占內存的大小。
7、sizeof后如果是類型必須加括弧，如果是變量名可以不加括弧。這是因為sizeof是個操作符不是個函數。
8、當適用了於一個結構類型時或變量， sizeof 返回實際的大小，當適用一靜態地空間數組， sizeof 歸還全部數組的尺寸。
sizeof 操作符不能返回動態地被分派了的數組或外部的數組的尺寸。
9、數組作為參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，如：
fun(char [8])
fun(char [])
都等價於 fun(char *)
在C++里參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小。如果想在函數內知道數組的大小， 需要這樣做：進入函數后用memcpy拷貝出來，長度由另一個形參傳進去。

fun(unsiged char *p1, int len)
{
unsigned char* buf = new unsigned char[len+1]
memcpy(buf, p1, len);
}

我們能常在用到 sizeof 和 strlen 的時候，通常是計算字符串數組的長度。看了上面的詳細解釋，發現兩者的使用還是有區別的，從這個例子可以看得很清楚：

char str[20]="0123456789";
int a=strlen(str); //a=10; >>>> strlen 計算字符串的長度，以結束符 0x00 為字符串結束。
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中struct，class，union對齊分析

由於struct，class的類似性，這里主要對struct進行分析。而union和struct的主要區別在於：聯合類型操作數的sizeof是其最大字節成員的字節數。結構類型操作數的sizeof是這種類型對象的總字節數，包括任何填充在內。

請看下面的結構： 

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  
偏移量必須為sizeof(int)即4的倍數  
float  
偏移量必須為sizeof(float)即4的倍數  
double  
偏移量必須為sizeof(double)即8的倍數  
Short  
偏移量必須為sizeof(short)即2的倍數 

各成員變量在存放的時候根據在結構中出現的順序依次申請空間，同時按照上面的對齊方式調整位置，空缺的字節VC會自動填充（填充情況1）。同時VC為了確保結構的大小為結構的字節邊界數（即該結構中占用最大空間的類型所占用的字節數）的倍數，所以在為最后一個成員變量申請空間后，還會根據需要自動填充空缺的字節（填充情況2）。  
下面用前面的例子來說明VC到底怎么樣來存放結構的。  

struct   MyStruct
{
double   dda1;
char   dda;
int   type
}；

為上面的結構分配空間的時候，VC根據成員變量出現的順序和對齊方式，先為第一個成員dda1分配空間，其起始地址跟結構的起始地址相同（剛好偏移量0剛好為sizeof(double)的倍數），該成員變量占用sizeof(double)=8個字節；接下來為第二個成員dda分配空間，這時下一個可以分配的地址對於結構的起始地址的偏移量為8，是sizeof(char)的倍數，所以把dda存放在偏移量為8的地方滿足對齊方式，該成員變量占用sizeof(char)=1個字節；接下來為第三個成員type分配空間，這時下一個可以分配的地址對於結構的起始地址的偏移量為9，不是sizeof(int)=4的倍數，為了滿足對齊方式對偏移量的約束問題，VC自動填充3個字節（這三個字節沒有放什么東西），這時下一個可以分配的地址對於結構的起始地址的偏移量為12，剛好是sizeof(int)=4的倍數，所以把type存放在偏移量為12的地方，該成員變量占用sizeof(int)=4個字節；這時整個結構的成員變量已經都分配了空間，總的占用的空間大小為：8+1+3+4=16，剛好為結構的字節邊界數（即結構中占用最大空間的類型所占用的字節數sizeof(double)=8）的倍數，所以沒有空缺的字節需要填充。所以整個結構的大小為：sizeof(MyStruct)=8+1+3+4=16，其中有3個字節是VC自動填充的，沒有放任何有意義的東西。  
下面再舉個例子，交換一下上面的MyStruct的成員變量的位置，使它變成下面的情況：  

struct   MyStruct
{
char   dda;
double   dda1;
int   type
}；

這個結構占用的空間為多大呢？在VC6.0環境下，可以得到sizeof(MyStruc)為24。結合上面提到的分配空間的一些原則，分析下VC怎么樣為上面的結構分配空間的。（簡單說明）  

struct   MyStruct
{
    char   dda;//偏移量為0，滿足對齊方式，dda占用1個字節；
double   dda1;//下一個可用的地址的偏移量為1，不是sizeof(double)=8
                          //的倍數，需要補足7個字節才能使偏移量變為8（滿足對齊
                          //方式），因此VC自動填充7個字節，dda1存放在偏移量為8
                          //的地址上，它占用8個字節。即滿足填充情況1
int   type；//下一個可用的地址的偏移量為16，是sizeof(int)=4的倍
                      //數，滿足int的對齊方式，所以不需要VC自動填充，type存
                      //放在偏移量為16的地址上，它占用4個字節。
}；//所有成員變量都分配了空間，空間總的大小為1+7+8+4=20，不是結構
      //的節邊界數（即結構中占用最大空間的類型所占用的字節數sizeof
      //(double)=8）的倍數，所以需要填充4個字節，以滿足結構的大小為
      //sizeof(double)=8的倍數。  即滿足填充情況2

所以該結構總的大小為：sizeof(MyStruc)為1+7+8+4+4=24。其中總的有7+4=11個字節是VC自動填充的，沒有放任何有意義的東西。  
VC對結構的存儲的特殊處理確實提高CPU存儲變量的速度，但是有時候也帶來了一些麻煩，我們也屏蔽掉變量默認的對齊方式，自己可以設定變量的對齊方式。  VC中提供了#pragma   pack(n)來設定變量以n字節對齊方式。n字節對齊就是說變量存放的起始地址的偏移量有兩種情況：

第一、如果n大於等於該變量所占用的字節數，那么偏移量必須滿足默認的對齊方式；

第二、如果n小於該變量的類型所占用的字節數，那么偏移量為n的倍數，不用滿足默認的對齊方式。結構的總大小也有個約束條件，分下面兩種情況：如果n大於所有成員變量類型所占用的字節數，那么結構的總大小必須為占用空間最大的變量占用的空間數的倍數；  
否則必須為n的倍數。下面舉例說明其用法。  

#pragma   pack(push)   //保存對齊狀態
#pragma   pack(4)//設定為4字節對齊
struct   test
{
    char   m1;
    double   m4;
    int     m3;
};
#pragma   pack(pop)//恢復對齊狀態

以上結構的大小為16。  下面分析其存儲情況，首先為m1分配空間，其偏移量為0，滿足我們自己設定的對齊方式（4字節對齊），m1占用1個字節。接着開始為m4分配空間，這時其偏移量為1，需要補足3個字節，這樣使偏移量滿足為n=4的倍數（因為sizeof(double)大於n）,m4占用8個字節。接着為m3分配空間，這時其偏移量為12，滿足為4的倍數，m3占用4個字節。這時已經為所有成員變量分配了空間，共分配了16個字節，滿足為n的倍數。

如果把上面的#pragma   pack(4)改為#pragma   pack(16)，那么我們可以得到結構的大小為24。（請讀者自己分析）  
同理，可以根據填充情況1和填充情況2對下列幾個例子進行分析。

1、

struct stu
{
    union
    {
        char b[5];
        int bh[2];
    }uu;
    float cj;
    char xm[8];
}xc;

結果：20

2、

struct stu
{
    union
    {
        char b[5];
        double x;
    }uu;
    float cj;
    char xm[8];
}xc;

結果：24

3、

struct stu
{
    union
    {
        char b[5];
    }uu;
    float cj;
    char xm[8];
}xc;

結果：20

最后再附上一個虛繼承中sizeof的關系，讀者可自行分析。

class Base1
{
public:
    int data;
    virtual void display();
};
class Base2
{};

class Derive1:public Base1
{};

class Derive2:public virtual Base2
{};

class Derive3:public Base1,public Base2
{};


cout<<"sizeof(Base1):"<<sizeof(Base1)<<endl;
cout<<"sizeof(Derive1):"<<sizeof(Derive1)<<endl;
cout<<"sizeof(Derive2):"<<sizeof(Derive2)<<endl;
cout<<"sizeof(Derive3):"<<sizeof(Derive3)<<endl;

結果：8,8,4,8

對於類而言，類的大小與下列數據有關：

１．為類的非靜態成員數據的類型大小之和．

２．有編譯器額外加入的成員變量的大小，用來支持語言的某些特性（如：指向虛函數的指針）．

３．為了優化存取效率，進行的邊緣調整．

４　與類中的構造函數，析構函數以及其他的成員函數無關．

對於union的情況，主要參考：sizeof a union in C/C++

int main() {
  union {
    char all[13];
    int foo;
  } record;

printf("%d\n",sizeof(record.all));
printf("%d\n",sizeof(record.foo));
printf("%d\n",sizeof(record));

}

輸出結果為

13 4 16

為了避免字節填充，可采用類似struct中的方法，用pack預處理指令來禁止編譯器對齊調整。

int main() {
#pragma pack(push, 1)
      union {
           char all[13];
           int foo;
      } record;
#pragma pack(pop)

      printf("%d\n",sizeof(record.all));
      printf("%d\n",sizeof(record.foo));
      printf("%d\n",sizeof(record));

}

輸出結果為：

13 4 13

具體的可參考相應的反匯編結果：

0x00001fd2 <main+0>:    push   %ebp             |  0x00001fd2 <main+0>:    push   %ebp
  0x00001fd3 <main+1>:    mov    %esp,%ebp        |  0x00001fd3 <main+1>:    mov    %esp,%ebp
  0x00001fd5 <main+3>:    push   %ebx             |  0x00001fd5 <main+3>:    push   %ebx
  0x00001fd6 <main+4>:    sub    $0x24,%esp       |  0x00001fd6 <main+4>:    sub    $0x24,%esp
  0x00001fd9 <main+7>:    call   0x1fde <main+12> |  0x00001fd9 <main+7>:    call   0x1fde <main+12>
  0x00001fde <main+12>:   pop    %ebx             |  0x00001fde <main+12>:   pop    %ebx
  0x00001fdf <main+13>:   movl   $0xd,0x4(%esp)   |  0x00001fdf <main+13>:   movl   $0x10,0x4(%esp)
  0x00001fe7 <main+21>:   lea    0x1d(%ebx),%eax  |  0x00001fe7 <main+21>:   lea    0x1d(%ebx),%eax
  0x00001fed <main+27>:   mov    %eax,(%esp)      |  0x00001fed <main+27>:   mov    %eax,(%esp)
  0x00001ff0 <main+30>:   call  0x3005 <printf>   |  0x00001ff0 <main+30>:   call   0x3005 <printf>
  0x00001ff5 <main+35>:   add    $0x24,%esp       |  0x00001ff5 <main+35>:   add    $0x24,%esp
  0x00001ff8 <main+38>:   pop    %ebx             |  0x00001ff8 <main+38>:   pop    %ebx
  0x00001ff9 <main+39>:   leave                   |  0x00001ff9 <main+39>:   leave
  0x00001ffa <main+40>:   ret                     |  0x00001ffa <main+40>:   ret

參考資料：

1、http://topic.csdn.net/t/20041118/13/3564818.html

2、http://stackoverflow.com/questions/740577/sizeof-a-union-in-c-c