在 Pascal 語言中，sizeof() 是一種記憶體容量度量函式，功能是返回一個變數或者類型的大小（以位元組為單位）；在 C 語言中，sizeof() 是一個判斷數據類型或者表達式長度的運算符。
在Pascal 語言與C語言中，對 sizeof() 的處理都是在編譯階段進行。
基本介紹
- 外文名：sizeof
- 定義：是C/C++中的一個操作符
- 作用：判斷數據類型長度符的關鍵字
- 類型：計算機專用名稱
- 過程：位元組數的計算在程式編譯時進行
- 返回值：記憶體所占位元組數
Pascal中的用法,C語言中,用法,定義,語法,sizeof的常量性,指針變數的sizeof,結構體的sizeof,與strlen區別,
Pascal中的用法
Vara:array[1..10000] of longint;BeginWriteln(SizeOf(a));End.
輸出：
40000
如果longint改為Integer，也輸出（Pascal中longInt和Integer都是4位元組）:
40000
C語言中
判斷數據類型長度符的關鍵字
用法
sizeof (類型說明符)
sizeof 表達式
sizeof 表達式
定義
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.
typedef unsigned int size_t;
語法
sizeof有兩種語法形式，如下：
sizeof(type_name);//sizeof(類型);sizeof object;//sizeof對象;
所以，
int i;sizeof(i);//oksizeof i;//oksizeof(int);//oksizeof 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);//errorvoid foo2(){}sizeof(foo2());//errorstruct S{unsigned int f1:1;unsigned int f2:5;unsigned int f3:12;};sizeof(S.f1);//errorsizeof的常量性
char ary[sizeof(int)*10];//ok
最新的C99標準規定sizeof也可以在運行時刻進行計算，如下面的程式在Dev-C++中可以正確執行：
int n;n=10;//n動態賦值char ary[n];//C99也支持數組的動態定義printf("%d\n",sizeof(ary));//ok.輸出10但在沒有完全實現C99標準的編譯器中就行不通了，上面的代碼在VC6中就通不過編譯。所以我們最好還是認為sizeof是在編譯期執行的，這樣不會帶來錯誤，讓程式的可移植性強些。
基本數據類型的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);//結果為4sizeof(pi);//結果為4sizeof(ps);//結果為4sizeof(ppc);//結果為4sizeof(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。
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)結構體變數的首地址能夠被其最寬基本類型成員的大小所整除；
2)結構體每個成員相對於結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充位元組（internal padding）；
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(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。
如今，朋友們可以輕鬆的出一口氣了，:)
還有一點要注意，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區別
strlen(char*)函式求的是字元串的實際長度，直到遇到第一個'\0'，然後就返回計數值，且不包括'\0'。
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()函式返回的是變數聲明後所占的記憶體數，不是實際長度。
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。
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.數組作為參數傳給函式時傳的是指針而不是數組，傳遞的是數組的首地址，
如：
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++里參數傳遞數組永遠都是傳遞指向數組首元素的指針，編譯器不知道數組的大小，如果想在函式內知道數組的大小， 需要這樣做：
進入函式後用memcpy拷貝出來，長度由另一個形參傳進去
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) //結果 4 --->str是指向字元串常量的字元指針，sizeof 獲得的是一個指針所占的空間,應該是長整型的，所以是4；
sizeof(*str) //結果 1 --->*str是第一個字元，其實就是字元串的第一位'a' 所占的記憶體空間，是char類型的，占了 1 位；
strlen(str)= 5 //--->若要獲得這個字元串的長度，則一定要使用 strlen
char* str = "abacd";
sizeof(str) //結果 4 --->str是指向字元串常量的字元指針，sizeof 獲得的是一個指針所占的空間,應該是長整型的，所以是4；
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返回字元個數. //正確
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+1sizeof(*ss)結果1===》*ss是第一個字元char ss[100]="0123456789";sizeof(ss)結果是100===》ss表示在記憶體中的大小100×1strlen(ss)結果是10===》strlen是個函式內部實現是用一個循環計算到\0為止之前int ss[100]="0123456789";sizeof(ss)結果400===》ss表示在記憶體中的大小100×4strlen(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是4char 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;//32cout<<sizeofr<<endl;//也是32system("PAUSE");}r 引用的是整個的 test 對象而不是指向 test 的指針，所以 sizeof r 的結果和 sizeof test 完全相同。
