-
sizeof
鎖定
在Pascal 語言與C語言中，對 sizeof() 的處理都是在編譯階段進行。
- 外文名
- sizeof
- 定 義
- 是C/C++中的一個操作符
- 作 用
- 判斷數據類型長度符的關鍵字
- 類 型
- 計算機專用名稱
- 過 程
- 字節數的計算在程序編譯時進行
- 返回值
- 內存所佔字節數
目錄
- 1 Pascal中的用法
- 2 C語言中
sizeofPascal中的用法
Var a:array[1..10000] of longint; Begin Writeln(SizeOf(a)); End.
輸出：
40000
如果longint改為Integer，也輸出（Pascal中longInt和Integer都是4字節）:
40000
sizeofC語言中
判斷數據類型長度符的關鍵字
用法
sizeof (類型説明符)
sizeof 表達式
定義
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.
typedef unsigned int size_t;
語法
sizeof有兩種語法形式，如下：
sizeof(type_name);//sizeof(類型); sizeof object;//sizeof對象;
所以，
int i; sizeof(i);//ok sizeof i;//ok sizeof(int);//ok sizeof int;//error
sizeof計算對象的大小也是轉換成對對象類型的計算，也就是説，同種類型的不同對象其sizeof值都是一致的。sizeof對一個表達式求值，編譯器根據表達式的最終結果類型來確定大小，一般不會對錶達式進行計算。如：
sizeof(2);//2的類型為int，所以等價於sizeof(int); sizeof(2+3.14);//3.14的類型為double，2也會被提升成double類型，所以等價於sizeof(double);
sizeof也可以對一個函數調用求值，其結果是函數返回類型的大小，函數並不會被調用，我們來看一個完整的例子：
char foo()
{
printf("foo()hasbeencalled.\n");
return 'a';
}
int main()
{
size_tsz=sizeof(foo());
//foo()的返回值類型為char，所以sz=sizeof(char)，foo()並不會被調用
printf("sizeof(foo())=%d\n",sz);
}
sizeof(foo);//error
void foo2(){}
sizeof(foo2());//error
struct S
{
unsigned int f1:1;
unsigned int f2:5;
unsigned int f3:12;
};
sizeof(S.f1);//error
sizeof的常量性
sizeof的計算發生在編譯時刻，所以它可以被當作常量表達式使用，如：
char ary[sizeof(int)*10];//ok
int n;
n=10;//n動態賦值
char ary[n];//C99也支持數組的動態定義
printf("%d\n",sizeof(ary));//ok.輸出10
基本數據類型的sizeof
這裏的基本數據類型指short、int、long、float、double這樣的簡單內置數據類型，由於它們都是和系統相關的，所以在不同的系統下取值可能不同，這務必引起我們的注意，儘量不要在這方面給自己程序的移植造成麻煩。
一般的，在32位編譯環境中，sizeof(int)的取值為4。
指針變量的sizeof
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
指針變量的sizeof值與指針所指的對象沒有任何關係，正是由於所有的指針變量所佔內存大小相等，所以MFC消息處理函數使用兩個參數WPARAM、LPARAM就能傳遞各種複雜的消息結構（使用指向結構體的指針）。
數組的sizeof
數組的sizeof值等於數組所佔用的內存字節數，如：
char a1[] = "abc"; int a2[3]; sizeof( a1 ); // 結果為4，字符末尾還存在一個NULL終止符 sizeof( a2 ); // 結果為3*4=12（依賴於int）
一些朋友剛開始時把sizeof當作了求數組元素的個數，如今你應該知道這是不對的，那麼應該怎麼求數組元素的個數呢Easy，通常有下面兩種寫法：
int c1=sizeof(a1)/sizeof(char);//總長度/單個元素的長度 char型 int c2=sizeof(a2)/sizeof(a2[0]);//總長度/第一個元素的長度 int型
寫到這裏，提一問，下面的c3，c4值應該是多少呢
void foo3(char a3[3])
{
int c3=sizeof(a3);//c3==
}
void foo4(char a4[])
{
int c4=sizeof(a4);//c4==
}
也許當你試圖回答c4的值時已經意識到c3答錯了，是的，c3!=3。這裏函數參數a3已不再是數組類型，而是蜕變成指針，相當於char* a3，為什麼仔細想想就不難明白，我們調用函數foo3時，程序會在棧上分配一個大小為3的數組嗎不會！數組是“傳址”的，調用者只需將實參的地址傳遞過去，所以a3自然為指針類型（char*），c3的值也就為4。
結構體的sizeof
這是初學者問得最多的一個問題，所以這裏有必要多費點筆墨。讓我們先看一個結構體：
struct S1{char c;int i;};
問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{int i;char c;};
看看sizeof(S2)的結果為多少，怎麼還是8再看看內存，原來成員c後面仍然有3個填充字節，這又是為什麼啊彆着急，下面總結規律。
(1)結構體變量的首地址能夠被其最寬基本類型成員的大小所整除；
(3)結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之後加上填充字節（trailing padding）。
對於上面的準則，有幾點需要説明：
(1) 前面不是説結構體成員的地址是其大小的整數倍，怎麼又説到偏移量了呢因為有了第1點存在，所以我們就可以只考慮成員的偏移量，這樣思考起來簡單。想想為什麼。
#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{char c1;S1 s;char c2;};
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。
通過上面的敍述，我們可以得到一個公式：
sizeof(struct)=offsetof(lastitem)+sizeof(lastitem)+sizeof(trailingpadding)
到這裏，朋友們應該對結構體的sizeof有了一個全新的認識，但不要高興得太早，有一個影響sizeof的重要參量還未被提及，那便是編譯器的pack指令。它是用來調整結構體對齊方式的，不同編譯器名稱和用法略有不同，VC6中通過#pragmapack實現，也可以直接修改/Zp編譯開關。#pragmapack的基本用法為：
#pragmapack(n)
公式如下：
offsetof(item)=min(n,sizeof(item))
再看示例：
#pragmapack(push)//將當前pack設置壓棧保存
#pragmapack(2)//必須在結構體定義之前使用
struct S1{char c;int i;};
struct S3{char c1;S1 s;char c2;};
#pragmapack(pop)//恢復先前的pack設置
同樣，對於sizeof(S3)，s的偏移量為2，c2的偏移量為8，加上sizeof(c2)等於9，不能被2整除，添加一個填充字節，所以sizeof(S3)等於10。
如今，朋友們可以輕鬆的出一口氣了，
還有一點要注意，C++中“空結構體”（不含數據成員）的大小不為0，而是1。試想一個“不佔空間”的變量如何被取地址、兩個不同的“空結構體”變量又如何得以區分呢於是，“空結構體”變量也得被存儲，這樣編譯器也就只能為其分配一個字節的空間用於佔位了。如下：
struct S5 { }; sizeof( S5 ); // 結果為1含位域結構體的sizeof
C99規定int、unsigned int和bool可以作為位域類型，但編譯器幾乎都對此作了擴展，允許其它類型類型的存在。使用位域的主要目的是壓縮存儲，其大致規則為：
(1) 如果相鄰位域字段的類型相同，且其位寬之和小於類型的sizeof大小，則後面的字段將緊鄰前一個字段存儲，直到不能容納為止；
(4) 如果位域字段之間穿插着非位域字段，則不進行壓縮；
(5) 整個結構體的總大小為最寬基本類型成員大小的整數倍。
還是讓我們來看看例子。
示例1：
struct BF1{char f1:3;char f2:4;char f3:5;};
其內存佈局為：
|_f1__|__f2__|_|____f3___|____| |_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|
0 3 7 8 1316
位域類型為char，第1個字節僅能容納下f1和f2，所以f2被壓縮到第1個字節中，而f3只
能從下一個字節開始。因此sizeof(BF1)的結果為2。
示例2：
struct BF2{char f1:3;short f2:4;char f3:5;};
由於相鄰位域類型不同，在VC6中其sizeof為3，在Dev-C++中為2。
示例3：
struct BF3{char f1:3;char f2;char f3:5;};
非位域字段穿插在其中，不會產生壓縮，在VC6和Dev-C++中得到的大小均為3。
9.聯合體的sizeof
結構體在內存組織上是順序式的，聯合體則是重疊式，各成員共享一段內存，所以整個聯合體的sizeof也就是每個成員sizeof的最大值的對齊結果。結構體的成員也可以是複合類型，這裏，複合類型成員是被作為整體考慮的。
所以，下面例子中，U的sizeof值等於sizeof(s)。
union U
{
int i;
char c;
S1 s;
};
與strlen區別
char aa[10];cout＜＜strlen(aa)＜＜endl; //結果是不定的，因為未初始化，'\0'在內存中的位置不確定
char aa[10]={'\0'}; cout＜＜strlen(aa)＜＜endl; //結果為0
char aa[10]="jun"; cout＜＜strlen(aa)＜＜endl; //結果為3
sizeof(aa) 返回10 int a[10]; sizeof(a) 返回40
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。
4.數組做sizeof的參數不退化，傳遞給strlen就退化為指針了。
char str[20]="0123456789"; int a=strlen(str);//a=10; int b=sizeof(str);//而b=20;
6.strlen的結果要在運行的時候才能計算出來，是用來計算字符串的長度，不是類型佔內存的大小。
7.sizeof後如果是類型必須加括弧，如果是變量名可以不加括弧。這是因為sizeof是個操作符不是個函數。
8.數組作為參數傳給函數時傳的是指針而不是數組，傳遞的是數組的首地址，
如：
fun(char[8])fun(char[])
都等價於 fun(char *)
特別注意：
sizeof是運算符，strlen是函數，具體如下：
sizeof
strlen
頭文件：stddef.h格式：
1) sizeof( type_name ); // sizeof( 類型 );
2) sizeof object; // sizeof 對象
功能：一個對象或者類型所佔的內存字節數;
説明：sizeof操作符的結果類型是size_t，typedef unsigned int size_t;
原型：extern unsigned int strlen(char *s);頭文件：string.h
格式：strlen (字符數組名)
功能：計算字符串s的(unsigned int型)長度,不包括'\0'在內
説明：返回s的長度，不包括結束符NULL。
在C++裏參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小，如果想在函數內知道數組的大小， 需要這樣做：
fun(unsiged char*p1,int len)
{
unsigned char*buf=new unsigned char[len+1];
memcpy(buf,p1,len);
}
常在用到 sizeof 和 strlen 的時候，通常是計算字符串數組的長度，如果是對指針，結果則會不一樣的：
char* str = "abacd";
sizeof(*str) //結果 1 --->*str是第一個字符，其實就是字符串的第一位'a' 所佔的內存空間，是char類型的，佔了 1 位；
strlen(str)= 5 //--->若要獲得這個字符串的長度，則一定要使用 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返回對象所佔用的字節大小. //正確
strlen返回字符個數. //正確
在使用sizeof時，有一個很特別的情況，就是數組名到指針蜕變，
char Array[3]={'0'};
sizeof(Array)==3;
char*p=Array;
strlen(p)==1;//sizeof(p)結果為4
在傳遞一個數組名到一個函數中時，它會完全退化為一個指針
大部分編譯程序 在編譯的時候就把sizeof計算過了 是類型或是變量的長度
這就是sizeof(x)可以用來定義數組維數的原因
char str[20]="0123456789"; int a=strlen(str);//a=10; int b=sizeof(str);//而b=20; char ss[]="0123456789"; sizeof(ss)結果11===》ss是數組，計算到\0位置，因此是10+1 sizeof(*ss)結果1===》*ss是第一個字符 char ss[100]="0123456789"; sizeof(ss)結果是100===》ss表示在內存中的大小100×1 strlen(ss)結果是10===》strlen是個函數內部實現是用一個循環計算到\0為止之前 int ss[100]="0123456789"; sizeof(ss)結果400===》ss表示在內存中的大小100×4 strlen(ss)錯誤===》strlen的參數只能是char*且必須是以'\0'結尾的 char q[]="abc"; char p[]="a\n"; sizeof(q),sizeof(p),strlen(q),strlen(p);
結果是 4 3 3 2
第三個例子
char szPath[MAX_PATH]
如果在函數內這樣定義，那麼sizeof(szPath)將會是MAX_PATH，但是將szPath作為虛參聲明時
（void fun(charszPath[MAX_PATH]))
sizeof(szPath) 卻會是4(指針大小)
還有一位網友的説明也很好：
其實理解 sizeof 只需要抓住一個要點：棧
程序存儲分佈有三個區域：棧、靜態和動態。能夠從代碼直接操作的對象，包括任何類型的變量、指針，都是在棧上的；動態和靜態存儲區是靠棧上的所有指針間接操作的。 sizeof 操作符，計算的是對象在棧上的投影體積；記住這個就很多東西都很清楚了。
char const*static_string="Hello"; //sizeof(static_string)是sizeof一個指針，所以在32bitsystem是4 char stack_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 一個被引用的對象的大小；所以
struct test
{
int a,b,c,d,e,f,g,h;
};
int main()
{
test&r=*newtest;
cout<<sizeof(test)<<endl;//32
cout<<sizeofr<<endl;//也是32
system("PAUSE");
}
r 引用的是整個的 test 對象而不是指向 test 的指針，所以 sizeof r 的結果和 sizeof test 完全相同。
