#
函數(shù)指針的聲明和回調(diào)的實現(xiàn)
?? 程序員常常需要實現(xiàn)回調(diào)。本文將討論函數(shù)指針的基本原則并說明如何使用函數(shù)指針實現(xiàn)回調(diào)。注意這里針對的是普通的函數(shù)，不包括完全依賴于不同語法和語義規(guī)則的類成員函數(shù)（類成員指針將在另文中討論）。
聲明函數(shù)指針
?? 回調(diào)函數(shù)是一個程序員不能顯式調(diào)用的函數(shù)；通過將回調(diào)函數(shù)的地址傳給調(diào)用者從而實現(xiàn)調(diào)用。要實現(xiàn)回調(diào)，必須首先定義函數(shù)指針。盡管定義的語法有點不可思議，但如果你熟悉函數(shù)聲明的一般方法，便會發(fā)現(xiàn)函數(shù)指針的聲明與函數(shù)聲明非常類似。請看下面的例子：
void f()；// 函數(shù)原型
上面的語句聲明了一個函數(shù)，沒有輸入?yún)?shù)并返回void。那么函數(shù)指針的聲明方法如下：
void (*) ();
?? 讓我們來分析一下，左邊圓括弧中的星號是函數(shù)指針聲明的關(guān)鍵。另外兩個元素是函數(shù)的返回類型（void）和由邊圓括弧中的入口參數(shù)（本例中參數(shù)是空）。注意本例中還沒有創(chuàng)建指針變量-只是聲明了變量類型。目前可以用這個變量類型來創(chuàng)建類型定義名及用sizeof表達式獲得函數(shù)指針的大小：
// 獲得函數(shù)指針的大小
unsigned psize = sizeof (void (*) ());
// 為函數(shù)指針聲明類型定義
typedef void (*pfv) ();
pfv是一個函數(shù)指針，它指向的函數(shù)沒有輸入?yún)?shù)，返回類行為void。使用這個類型定義名可以隱藏復雜的函數(shù)指針語法。
指針變量應該有一個變量名：
void (*p) (); //p是指向某函數(shù)的指針
?? p是指向某函數(shù)的指針，該函數(shù)無輸入?yún)?shù)，返回值的類型為void。左邊圓括弧里星號后的就是指針變量名。有了指針變量便可以賦值，值的內(nèi)容是署名匹配的函數(shù)名和返回類型。例如：
void func()
{
/* do something */
}
p = func;
p的賦值可以不同，但一定要是函數(shù)的地址，并且署名和返回類型相同。
傳遞回調(diào)函數(shù)的地址給調(diào)用者
?? 現(xiàn)在可以將p傳遞給另一個函數(shù)（調(diào)用者）- caller()，它將調(diào)用p指向的函數(shù)，而此函數(shù)名是未知的：
void caller(void(*ptr)())
{
ptr(); /* 調(diào)用ptr指向的函數(shù) */
}
void func();
int main()
{
p = func;
caller(p); /* 傳遞函數(shù)地址到調(diào)用者 */
}
?? 如果賦了不同的值給p（不同函數(shù)地址），那么調(diào)用者將調(diào)用不同地址的函數(shù)。賦值可以發(fā)生在運行時，這樣使你能實現(xiàn)動態(tài)綁定。
調(diào)用規(guī)范
?? 到目前為止，我們只討論了函數(shù)指針及回調(diào)而沒有去注意ANSI C/C++的編譯器規(guī)范。許多編譯器有幾種調(diào)用規(guī)范。如在Visual C++中，可以在函數(shù)類型前加_cdecl，_stdcall或者_pascal來表示其調(diào)用規(guī)范（默認為_cdecl）。C++ Builder也支持_fastcall調(diào)用規(guī)范。調(diào)用規(guī)范影響編譯器產(chǎn)生的給定函數(shù)名，參數(shù)傳遞的順序（從右到左或從左到右），堆棧清理責任（調(diào)用者或者被調(diào)用者）以及參數(shù)傳遞機制（堆棧，CPU寄存器等）。
?? 將調(diào)用規(guī)范看成是函數(shù)類型的一部分是很重要的；不能用不兼容的調(diào)用規(guī)范將地址賦值給函數(shù)指針。例如：
// 被調(diào)用函數(shù)是以int為參數(shù)，以int為返回值
__stdcall int callee(int);
// 調(diào)用函數(shù)以函數(shù)指針為參數(shù)
void caller( __cdecl int(*ptr)(int));
// 在p中企圖存儲被調(diào)用函數(shù)地址的非法操作
__cdecl int(*p)(int) = callee; // 出錯
?? 指針p和callee()的類型不兼容，因為它們有不同的調(diào)用規(guī)范。因此不能將被調(diào)用者的地址賦值給指針p，盡管兩者有相同的返回值和參數(shù)列。
摘要: 對象的動態(tài)分配（Dynamically Allocated Object）
Posted on 2006-08-05 12:55 一秋草木 閱讀(291) 評論(4) ?編輯?收藏收藏至365Key 所屬分類: C++
-->
1
、對象的分類
...
閱讀全文
mutable關(guān)鍵字
關(guān)鍵字mutable是C++中一個不常用的關(guān)鍵字,他只能用于類的非靜態(tài)和非常量數(shù)據(jù)成員
我們知道一個對象的狀態(tài)由該對象的非靜態(tài)數(shù)據(jù)成員決定,所以隨著數(shù)據(jù)成員的改變,
對像的狀態(tài)也會隨之發(fā)生變化!
如果一個類的成員函數(shù)被聲明為const類型,表示該函數(shù)不會改變對象的狀態(tài),也就是
該函數(shù)不會修改類的非靜態(tài)數(shù)據(jù)成員.但是有些時候需要在該類函數(shù)中對類的數(shù)據(jù)成員
進行賦值.這個時候就需要用到mutable關(guān)鍵字了
例如:
class Demo
{
public:
??? Demo(){}
??? ~Demo(){}
public:
??? bool getFlag() const
??? {
??????? m_nAccess++;
??????? return m_bFlag;
??? }
private:
??? int? m_nAccess;
??? bool m_bFlag;
};
int main()
{
??? return 0;
}
編譯上面的代碼會出現(xiàn) error C2166: l-value specifies const object的錯誤
說明在const類型的函數(shù)中改變了類的非靜態(tài)數(shù)據(jù)成員.
這個時候需要使用mutable來修飾一下要在const成員函數(shù)中改變的非靜態(tài)數(shù)據(jù)成員
m_nAccess,代碼如下:
class Demo
{
public:
??? Demo(){}
??? ~Demo(){}
public:
??? bool getFlag() const
??? {
??????? m_nAccess++;
??????? return m_bFlag;
??? }
private:
??? mutable int? m_nAccess;
??? bool m_bFlag;
};
int main()
{
??? return 0;
}
這樣再重新編譯的時候就不會出現(xiàn)錯誤了!
?
?
volatile關(guān)鍵字
volatile是c/c++中一個鮮為人知的關(guān)鍵字,該關(guān)鍵字告訴編譯器不要持有變量的臨時拷貝,它可以適用于基礎(chǔ)類型
如：int,char,long......也適用于C的結(jié)構(gòu)和C++的類。當對結(jié)構(gòu)或者類對象使用volatile修飾的時候，結(jié)構(gòu)或者
類的所有成員都會被視為volatile.
使用volatile并不會否定對CRITICAL_SECTION,Mutex,Event等同步對象的需要
例如：
int i;
i = i + 3;
無論如何，總是會有一小段時間，i會被放在一個寄存器中，因為算術(shù)運算只能在寄存器中進行。一般來說，volatitle
關(guān)鍵字適用于行與行之間，而不是放在行內(nèi)。
我們先來實現(xiàn)一個簡單的函數(shù)，來觀察一下由編譯器產(chǎn)生出來的匯編代碼中的不足之處，并觀察volatile關(guān)鍵字如何修正
這個不足之處。在這個函數(shù)體內(nèi)存在一個busy loop(所謂busy loop也叫做busy waits,是一種高度浪費CPU時間的循環(huán)方法)
void getKey(char* pch)
{
?while (*pch == 0)
??;
}
當你在VC開發(fā)環(huán)境中將最優(yōu)化選項都關(guān)閉之后，編譯這個程序，將獲得以下結(jié)果(匯編代碼)
;?????? while (*pch == 0)
$L27
?; Load the address stored in pch
?mov eax, DWORD PTR _pch$[ebp]
?; Load the character into the EAX register
?movsx eax, BYTE PTR [eax]
?; Compare the value to zero
?test eax, eax
?; If not zero, exit loop
?jne $L28
?;
?jmp $L27
$L28
;}
這段沒有優(yōu)化的代碼不斷的載入適當?shù)牡刂罚d入地址中的內(nèi)容，測試結(jié)果。效率相當?shù)牡停墙Y(jié)果非常準確
現(xiàn)在我們再來看看將編譯器的所有最優(yōu)化選項開關(guān)都打開以后，重新編譯程序，生成的匯編代碼，和上面的代碼
比較一下有什么不同
;{
?; Load the address stored in pch
?mov eax, DWORD PTR _pch$[esp-4]
?; Load the character into the AL register
?movsx al, BYTE PTR [eax]
;?while (*pch == 0)
?; Compare the value in the AL register to zero
?test al, al
?; If still zero, try again
?je SHORT $L84
?;
;}
從代碼的長度就可以看出來，比沒有優(yōu)化的情況要短的多。需要注意的是編譯器把MOV指令放到了循環(huán)之外。這在
單線程中是一個非常好的優(yōu)化，但是，在多線程應用程序中，如果另一個線程改變了變量的值，則循環(huán)永遠不會
結(jié)束。被測試的值永遠被放在寄存器中，所以該段代碼在多線程的情況下，存在一個巨大的BUG。解決方法是重新
寫一次getKey函數(shù)，并把參數(shù)pch聲明為volatile,代碼如下：
void getKey(volatile char* pch)
{
?while (*pch == 0)
??;
}
這次的修改對于非最優(yōu)化的版本沒有任何影響，下面請看最優(yōu)化后的結(jié)果：
;{
?; Load the address stored in pch
?mov eax, DWORD PTR _pch$[esp-4]
;?????? while (*pch == 0)
$L84:
?; Directly compare the value to zero
?cmp BYTE PTR [eax], 0
?; If still zero, try again
?je SHORT $L84
?;
;}
這次的修改結(jié)果比較完美，地址不會改變，所以地址聲明被移動到循環(huán)之外。地址內(nèi)容是volatile,所以每次循環(huán)
之中它不斷的被重新檢查。
把一個const volatile變量作為參數(shù)傳遞給函數(shù)是合法的。如此的聲明意味著函數(shù)不能改變變量的值，但是變量的
值卻可以被另一個線程在任何時間改變掉。
explicit關(guān)鍵字
我們在編寫應用程序的時候explicit關(guān)鍵字基本上是很少使用,它的作用是"禁止單參數(shù)構(gòu)造函數(shù)"被用于自動型別轉(zhuǎn)換,
其中比較典型的例子就是容器類型,在這種類型的構(gòu)造函數(shù)中你可以將初始長度作為參數(shù)傳遞給構(gòu)造函數(shù).
例如:
你可以聲明這樣一個構(gòu)造函數(shù)
class Array
{
public:
?explicit Array(int size);
?......
};
在這里explicit關(guān)鍵字起著至關(guān)重要的作用,如果沒有這個關(guān)鍵字的話,這個構(gòu)造函數(shù)有能力將int轉(zhuǎn)換成Array.一旦這種
情況發(fā)生,你可以給Array支派一個整數(shù)值而不會引起任何的問題,比如:
Array arr;
...
arr = 40;
此時,C++的自動型別轉(zhuǎn)換會把40轉(zhuǎn)換成擁有40個元素的Array,并且指派給arr變量,這個結(jié)果根本就不是我們想要的結(jié)果.如果
我們將構(gòu)造函數(shù)聲明為explicit,上面的賦值操作就會導致編譯器報錯,使我們可以及時發(fā)現(xiàn)錯誤.
需要注意的是:explicit同樣也能阻止"以賦值語法進行帶有轉(zhuǎn)型操作的初始化";
例如:
Array arr(40);//正確
Array arr = 40;//錯誤
看一下以下兩種操作:
X x;
Y y(x);//顯式類型轉(zhuǎn)換
另一種
X x;
Y y = x;//隱式類型轉(zhuǎn)換
這兩種操作存在一個小小的差別,第一種方式式通過顯式類型轉(zhuǎn)換,根據(jù)型別x產(chǎn)生了型別Y的新對象;第二種方式通過隱式轉(zhuǎn)換
產(chǎn)生了一個型別Y的新對象.
explicit關(guān)鍵字的應用主要就是上面所說的構(gòu)造函數(shù)定義種,參考該關(guān)鍵字的應用可以看看STL源代碼,其中大量使用了該關(guān)鍵字
?
__based關(guān)鍵字
該關(guān)鍵字主要用來解決一些和共享內(nèi)存有關(guān)的問題,它允許指針被定義為從某一點開始算的32位偏移值,而不是內(nèi)存種的絕對位置
舉個例子:
typedef struct tagDEMOSTRUCT {
?int a;
?char sz[10];
} DEMOSTRUCT, * PDEMOSTRUCT;
HANDLE hFileMapping = CreateFileMapping(...);
LPVOID lpShare = (LPDWORD)MapViewOfFile(...);
DEMOSTRUCT __based(lpShare)* lpDemo;
上面的例子聲明了一個指針lpDemo,內(nèi)部儲存的是從lpShare開始的偏移值,也就是lpHead是以lpShare為基準的偏移值.
上面的例子種的DEMOSTRUCT只是隨便定義的一個結(jié)構(gòu),用來代表任意的結(jié)構(gòu).
雖然__based指針使用起來非常容易,但是,你必須在效率上付出一定的代價.每當你用__based指針處理數(shù)據(jù),CPU都必須
為它加上基地址,才能指向真正的位置.
在這里我只是介紹了幾個并不時很常見的關(guān)鍵字的意義即用法,其他那些常見的關(guān)鍵字介紹他們的文章已經(jīng)不少了在這里
就不再一一介紹了.希望這些內(nèi)容能對大家有一定的幫助!
由一道面試題來看
Struct
的對界
?
本文節(jié)選自宋寶華的C/C++的struct深層探索一文，本人對其所描述的struct對齊比較喜歡，為此轉(zhuǎn)來與大家分享，原文見http://blog.donews.com/21cnbao/archive/2005/09/08/544877.aspx
?
Intel
、微軟等公司曾經(jīng)出過一道類似的面試題：
1. #include <iostream.h>
2. #pragma pack(8)
3. struct example1
4. {
5. ? ??short a;
6. ? ??long b;
7. };
8. struct example2
9. {
10. ?????? ??char c;
11. ?????? ??example1 struct1;
12. ?????? ??short e;
13. };
14. #pragma pack()
?
15. int main(int argc, char* argv[])
16. {
17. ?????? ??example2 struct2;
18. ??cout << sizeof(example1) << endl;
19. ??cout << sizeof(example2) << endl;
20. ??cout << (unsigned int)(&struct2.struct1) - (unsigned int)(&struct2)
<< endl;
21. return 0;
22. }
問程序的輸入結(jié)果是什么？
答案是：
8
16
4
不明白？還是不明白？下面一一道來：
1
、
自然對界
struct
是一種復合數(shù)據(jù)類型，其構(gòu)成元素既可以是基本數(shù)據(jù)類型（如
int
、
long
、
float
等）的變量，也可以是一些復合數(shù)據(jù)類型（如
array
、
struct
、
union
等）的數(shù)據(jù)單元。對于結(jié)構(gòu)體，編譯器會自動進行成員變量的對齊，以提高運算效率。缺省情況下，編譯器為結(jié)構(gòu)體的每個成員按其自然對界（
natural alignment
）條件分配空間。各個成員按照它們被聲明的順序在內(nèi)存中順序存儲，第一個成員的地址和整個結(jié)構(gòu)的地址相同。
自然對界
(natural alignment)
即默認對齊方式，是指按結(jié)構(gòu)體的成員中
size
最大的成員對齊。
例如：
struct naturalalign
{
char a;
short b;
char c;
};
在上述結(jié)構(gòu)體中，
size
最大的是
short
，其長度為
2
字節(jié)，因而結(jié)構(gòu)體中的
char
成員
a
、
c
都以
2
為單位對齊，
sizeof(naturalalign)
的結(jié)果等于
6
；
如果改為：
struct naturalalign
{
char a;
int b;
char c;
};
其結(jié)果顯然為
12
。
?
2
、
指定對界
一般地，可以通過下面的方法來改變?nèi)笔〉膶鐥l件：
·
使用偽指令
#pragma pack (n)
，編譯器將按照
n
個字節(jié)對齊；
·
使用偽指令
#pragma pack ()
，取消自定義字節(jié)對齊方式。
注意：如果
#pragma pack (n)
中指定的
n
大于結(jié)構(gòu)體中最大成員的
size
，則其不起作用，結(jié)構(gòu)體仍然按照
size
最大的成員進行對界。
例如：
#pragma pack (n)
struct naturalalign
{
char a;
int b;
char c;
};
#pragma pack ()
當
n
為
4
、
8
、
16
時，其對齊方式均一樣，
sizeof(naturalalign)
的結(jié)果都等于
12
。而當
n
為
2
時，其發(fā)揮了作用，使得
sizeof(naturalalign)
的結(jié)果為
8
。
摘要: C/C++
結(jié)構(gòu)體的一個高級特性
――
指定成員的位數(shù)
...
閱讀全文
1.在一個函數(shù)內(nèi)部定義的變量是內(nèi)部變量，它只在本函數(shù)范圍內(nèi)有效，在此函數(shù)外面是不能使用這個變量，稱之為 "局部變量"。形式參數(shù)也屬于局部變量。在函數(shù)中的一個程序塊（如某個復合語句｛...｝）定義的局部變量只在這個程序塊中有效，出了程序塊后就無效。
2.有時希望函數(shù)中的局部變量的值在函數(shù)調(diào)用之后不消失而保留原值，在下一次該函數(shù)調(diào)用時該變量已有值，這時就該制定該局部變量為"靜態(tài)局部變量"，用static加以說明。
3.在函數(shù)之外定義的變量稱之為全局變量，全局變量可以為本文件中其他函數(shù)所共用，其有效范圍為：從定義變量開始到本源文件結(jié)束。如果在定義點之前的函數(shù)想應用該全局變量，則應該在該函數(shù)中使用關(guān)鍵字 extern作外部變量說明，表示該變量在函數(shù)外部定義在函數(shù)內(nèi)部可以使用它。如果在同一個源文件中，全局變量和局部變量同名，則在局部變量作用范圍內(nèi)，全局變量不起作用。如果在其它文件中要引用該文件的全局變量，則需要在應用它的文件中，用extern作說明。
4.所謂靜態(tài)全局變量，就是希望某些全局變量只限定于被本文件引用，而不被其它文件引用，這時可以在定義全局變量的時候在前面加一個static說明，
?5 按存儲區(qū)域分，全局變量、靜態(tài)全局變量和靜態(tài)局部變量都存放在內(nèi)存的靜態(tài)存儲區(qū)域，局部變量存放在內(nèi)存的棧區(qū)。
??6?按作用域分，全局變量在整個工程文件內(nèi)都有效；靜態(tài)全局變量只在定義它的文件內(nèi)有效；靜態(tài)局部變量只在定義它的函數(shù)內(nèi)有效，只是程序僅分配一次內(nèi)存，函數(shù)返回后，該變量不會消失；局部變量在定義它的函數(shù)內(nèi)有效，但是函數(shù)返回后失效。
??7?全局變量和靜態(tài)變量如果沒有手工初始化，則由編譯器初始化為0。局部變量的值不可知。
8 舉個例子：
int a;??/*全局*/
static int b;??/*靜態(tài)全局*/
int main()
{
}
這段代碼如果是寫在file.c里面的，那么file2.c就不能調(diào)用b;
但是file2.c中可以通過聲明外部變量extent a;
9.靜態(tài)全局變量
全局變量(外部變量)的說明之前再冠以static 就構(gòu)成了靜態(tài)的全局變量。全局變量本身就是靜態(tài)存儲方式， 靜態(tài)全局變量當然也是靜態(tài)存儲方式。 這兩者在存儲方式上并無不同。這兩者的區(qū)別雖在于非靜態(tài)全局變量的作用域是整個源程序， 當一個源程序由多個源文件組成時，非靜態(tài)的全局變量在各個源文件中都是有效的。 而靜態(tài)全局變量則限制了其作用域， 即只在定義該變量的源文件內(nèi)有效， 在同一源程序的其它源文件中不能使用它。由于靜態(tài)全局變量的作用域局限于一個源文件內(nèi)，只能為該源文件內(nèi)的函數(shù)公用， 因此可以避免在其它源文件中引起錯誤。從以上分析可以看出， 把局部變量改變?yōu)殪o態(tài)變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變?yōu)殪o態(tài)變量后是改變了它的作用域， 限制了它
的使用范圍。因此static 這個說明符在不同的地方所起的作用是不同的。應予以注意。 |
10 代碼
//test.cpp
＃i nclude?<iostream.h>
extern?int?a;//變量聲明，不是定義
static?int?b=5;
void?func1()
{
??cout<<b<<endl<<a<<endl;//結(jié)果為5
}
//main.cpp
int?a;
int?b=10;
void?func2()
{
??static?int?i;
??i++;
??cout<<i<<endl;
}
void?func1();
void?main()
{
??a=20;
??func1();
??func2();
??func2();
}
輸出結(jié)果為
5
20
1
2
這篇文章轉(zhuǎn)載于
馬嘉楠 ，個人認為那位作者寫得有可取之處。
1. 定義：
??? sizeof是何方神圣？
??? sizeof 乃 C/C++ 中的一個操作符（operator）是也。簡單說其作用就是返回一個對象或者類型所占的內(nèi)存字節(jié)數(shù)。
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中定義。這是一個依賴于編譯系統(tǒng)的值，一般定義為
typedef unsigned int size_t;
??? 世上編譯器林林總總，但作為一個規(guī)范，它們都會保證char、signed char和unsigned char的sizeof值為1，畢竟char是我們編程能用的最小數(shù)據(jù)類型。
2. 語法：
??? sizeof有三種語法形式，如下：
??? 1) sizeof( object );??? // sizeof( 對象 );
??? 2) sizeof( type_name ); // sizeof( 類型 );
??? 3) sizeof object;?????? // sizeof 對象;
所以，
int i;
sizeof( i );???? // ok
sizeof i;?? ???? // ok
sizeof( int );?? // ok
sizeof int;????? // error
既然寫法2可以用寫法1代替，為求形式統(tǒng)一以及減少我們大腦的負擔，第2種寫法，忘掉它吧！
實際上，sizeof計算對象的大小也是轉(zhuǎn)換成對對象類型的計算。也就是說，同種類型的不同對象其sizeof值都是一致的。
這里，對象可以進一步延伸至表達式，即sizeof可以對一個表達式求值。編譯器根據(jù)表達式的最終結(jié)果類型來確定大小，一般不會對表達式進行計算。
例如：
sizeof( 2 );????????// 2的類型為int，所以等價于 sizeof( int );
sizeof( 2 + 3.14 );?// 3.14的類型為double，2也會被提升成double類型，所以等價于 sizeof( double );
??? sizeof也可以對一個函數(shù)調(diào)用求值，其結(jié)果是函數(shù)返回類型的大小，函數(shù)并不會被調(diào)用。我們來看一個完整的例子：
*********************************************************
char foo()
{
????printf("foo() has been called.\n");
????return 'a';
}
int main()
{
????size_t sz = sizeof( foo() );?? // foo() 的返回值類型為char，所以sz = sizeof(char)，但函數(shù)foo()并不會被調(diào)用
????printf("sizeof( foo() ) = %d\n", sz);
}
*********************************************************
C99標準規(guī)定，函數(shù)、不能確定類型的表達式以及位域（bit-field）成員不能被計算sizeof值，即下面這些寫法都是錯誤的：
??? 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
3. sizeof的常量性
??? sizeof的計算發(fā)生在編譯時刻，所以它可以被當作常量表達式使用。如：
char ary[ sizeof( int ) * 10 ];?? // ok
最新的C99標準規(guī)定sizeof也可以在運行時刻進行計算。如下面的程序在Dev-C++中可以正確執(zhí)行：
int n;
n = 10;??????? // n動態(tài)賦值
char ary[n];?? // C99也支持數(shù)組的動態(tài)定義
printf("%d\n", sizeof(ary)); // ok. 輸出10
但在沒有完全實現(xiàn)C99標準的編譯器中就行不通了，上面的代碼在VC6中就通不過編譯。所以我們最好還是認為sizeof是在編譯期執(zhí)行的，這樣不會帶來錯誤，讓程序的可移植性強些。
4. 基本數(shù)據(jù)類型的sizeof
這里的基本數(shù)據(jù)類型指short、int、long、float、double這樣的簡單內(nèi)置數(shù)據(jù)類型。由于它們都是和系統(tǒng)相關(guān)的，所以在不同的系統(tǒng)下取值可能不同。這務(wù)必引起我們的注意，盡量不要在這方面給自己程序的移植造成麻煩。
一般的，在32位編譯環(huán)境中，sizeof(int)的取值為4。
5. 指針變量的sizeof
學過數(shù)據(jù)結(jié)構(gòu)的你應該知道指針是一個很重要的概念，它記錄了另一個對象的地址。既然是來存放地址的，那么它當然等于計算機內(nèi)部地址總線的寬度。所以在32位計算機中，一個指針變量的返回值必定是4（注意結(jié)果是以字節(jié)為單位）。可以預計，在將來的64位系統(tǒng)中指針變量的sizeof結(jié)果為8。
*********************************************************
char* pc = "abc";
int* pi;
string* ps;
char** ppc = &pc;
void (*pf)();?// 函數(shù)指針
sizeof( pc ); // 結(jié)果為4
sizeof( pi ); // 結(jié)果為4
sizeof( ps ); // 結(jié)果為4
sizeof( ppc );// 結(jié)果為4
sizeof( pf ); // 結(jié)果為4
*********************************************************
指針變量的sizeof值與指針所指的對象沒有任何關(guān)系，正是由于所有的指針變量所占內(nèi)存大小相等，所以MFC消息處理函數(shù)使用兩個參數(shù)WPARAM、LPARAM就能傳遞各種復雜的消息結(jié)構(gòu)（使用指向結(jié)構(gòu)體的指針）。
6. 數(shù)組的sizeof
數(shù)組的sizeof值等于數(shù)組所占用的內(nèi)存字節(jié)數(shù)，如：
char a1[] = "abc";
int a2[3];
sizeof( a1 ); // 結(jié)果為4，字符 末尾還存在一個NULL終止符
sizeof( a2 ); // 結(jié)果為3*4=12（依賴于int）
一些朋友剛開始時把sizeof當作了求數(shù)組元素的個數(shù)，現(xiàn)在，你應該知道這是不對的。那么應該怎么求數(shù)組元素的個數(shù)呢？
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 ==
}
void foo4(char a4[])
{
????int c4 = sizeof( a4 ); // c4 ==
}
*********************************************************
也許當你試圖回答c4的值時已經(jīng)意識到c3答錯了，是的，c3!=3。
這里函數(shù)參數(shù)a3已不再是數(shù)組類型，而是蛻變成指針。相當于char* a3，為什么仔細想想就不難明白。
我們調(diào)用函數(shù)foo1時，程序會在棧上分配一個大小為3的數(shù)組嗎？不會！
數(shù)組是“傳址”的，調(diào)用者只需將實參的地址傳遞過去，所以a3自然為指針類型（char*），c3的值也就為4。
7.string的sizeof
一個string的大小與它所指向的字符串的長度無關(guān)。
*********************************************************
string st1("blog.sina.com.cn");
string st2("majianan");
string st3;
string *ps = &st1;
cout << "st1: " << sizeof(st1) << endl;
cout << "st2: " << sizeof(st2) << endl;
cout << "st3: " << sizeof(st3) << endl;
cout << "ps: " << sizeof(ps) << endl;
cout << "*ps: " << sizeof(*ps) << endl;
*********************************************************
輸出結(jié)果為：
st1： 28
st2： 28
st3： 28
ps： 4
*ps： 28
*********************************************************
對于不同的STL，String類的結(jié)構(gòu)定義會有所不同
所以不同的工具，例如VC++，和.NET，結(jié)果會有所不同，
在VC++6.0中（我的機器）結(jié)果是16
在.NET2003中結(jié)果是28
但是對于同一個編譯器，那么它的結(jié)果都是一定的
8.引用的sizeof
sizeof操作符應用在引用類型上的時候，返回的是包含被引用對象所需的內(nèi)存長度（即被引用對象的大小）
*********************************************************
cout << "short:\t" << sizeof(short) << endl;
cout << "short*:\t" << sizeof(short*) << endl;
cout << "short&:\t" << sizeof(short&) << endl;
cout << "short[4]:\t" << sizeof(short[4]) << endl;
cout << "int&:\t" << sizeof(int&) << endl;
*********************************************************
輸出結(jié)果為：
short： 2
short*： 4
short&： 2
short[4]： 8
int&： 4
9. 結(jié)構(gòu)體的sizeof
這是初學者問得最多的一個問題，所以這里有必要多費點筆墨。讓我們先看一個結(jié)構(gòu)體：
struct S1
{
??? char c;
??? int i;
};
問sizeof(s1)等于多少？
聰明的你開始思考了，char占1個字節(jié)，int占4個字節(jié)，那么加起來就應該是5。
是這樣嗎？
你在你機器上試過了嗎？
也許你是對的，但很可能你是錯的！
VC6中按默認設(shè)置得到的結(jié)果為8。
??? Why？為什么受傷的總是我？
請不要沮喪，我們來好好琢磨一下sizeof的定義 —— sizeof的結(jié)果等于對象或者類型所占的內(nèi)存字節(jié)數(shù)。好吧，那就讓我們來看看S1的內(nèi)存分配情況：
S1 s1 = { 'a', 0xFFFFFFFF };
定義上面的變量后，加上斷點，運行程序，觀察s1所在的內(nèi)存，你發(fā)現(xiàn)了什么？
以我的VC6.0為例，s1的地址為0x0012FF78，其數(shù)據(jù)內(nèi)容如下：
0012FF78: 61 CC CC CC FF FF FF FF
發(fā)現(xiàn)了什么？怎么中間夾雜了3個字節(jié)的CC？
看看MSDN上的說明：
When applied to a structure type or variable, sizeof returns the actual size, which may include padding bytes inserted for alignment.
原來如此，這就是傳說中的字節(jié)對齊啊！一個重要的話題出現(xiàn)了。
為什么需要字節(jié)對齊？
計算機組成原理教導我們，這樣有助于加快計算機的取數(shù)速度，否則就得多花指令周期了。
為此，編譯器默認會對結(jié)構(gòu)體進行處理（實際上其它地方的數(shù)據(jù)變量也是如此），讓寬度為2的基本數(shù)據(jù)類型（short等）都位于能被2整除的地址上，讓寬度為4的基本數(shù)據(jù)類型（int等）都位于能被4整除的地址上。以此類推，這樣，兩個數(shù)中間就可能需要加入填充字節(jié)，所以整個結(jié)構(gòu)體的sizeof值就增長了。
讓我們交換一下S1中char與int的位置：
struct S2
{
????int i;
????char c;
};
看看sizeof(S2)的結(jié)果為多少？怎么還是8。
再看看內(nèi)存，原來成員c后面仍然有3個填充字節(jié)。
這又是為什么啊？別著急，下面總結(jié)規(guī)律。
??? 字節(jié)對齊的細節(jié)和編譯器實現(xiàn)相關(guān)，但一般而言，滿足三個準則：
??? 1) 結(jié)構(gòu)體變量的首地址能夠被其最寬基本類型成員的大小所整除；
??? 2) 結(jié)構(gòu)體每個成員相對于結(jié)構(gòu)體首地址的偏移量（offset）都是成員大小的整數(shù)倍，如有需要編譯器會在成員之間加上填充字節(jié)（internal adding）；
??? 3) 結(jié)構(gòu)體的總大小為結(jié)構(gòu)體最寬基本類型成員大小的整數(shù)倍，如有需要編譯器會在最末一個成員之后加上填充字節(jié)（trailing padding）。
??? 對于上面的準則，有幾點需要說明：
1)?前面不是說結(jié)構(gòu)體成員的地址是其大小的整數(shù)倍，怎么又說到偏移量了呢？
因為有了第1點存在，所以我們就可以只考慮成員的偏移量，這樣思考起來簡單。想想為什么。
結(jié)構(gòu)體某個成員相對于結(jié)構(gòu)體首地址的偏移量可以通過宏offsetof()來獲得，這個宏也在stddef.h中定義，如下：
#define offsetof(s,m) (size_t)&(((s *)0)->m)
例如，想要獲得S2中c的偏移量，方法為
size_t pos = offsetof(S2, c);// pos等于4
2) 基本類型是指前面提到的像char、short、int、float、double這樣的內(nèi)置數(shù)據(jù)類型。這里所說的“數(shù)據(jù)寬度”就是指其sizeof的大小。由于結(jié)構(gòu)體的成員可以是復合類型，比如另外一個結(jié)構(gòu)體，所以在尋找最寬基本類型成員時，應當包括復合類型成員的子成員，而不是把復合成員看成是一個整體。但在確定復合類型成員的偏移位置時則是將復合類型作為整體看待。
這里敘述起來有點拗口，思考起來也有點撓頭，還是讓我們看看例子吧（具體數(shù)值仍以VC6為例，以后不再說明）：
struct S3
{
????char c1;
????S1 s;
????char c2;
};
S1的最寬簡單成員的類型為int，S3在考慮最寬簡單類型成員時是將S1“打散”看的，所以S3的最寬簡單類型為int。這樣，通過S3定義的變量，其存儲空間首地址需要被4整除，整個sizeof(S3)的值也應該被4整除。
c1的偏移量為0，s的偏移量呢？這時s是一個整體，它作為結(jié)構(gòu)體變量也滿足前面三個準則，所以其大小為8，偏移量為4，c1與s之間便需要3個填充字節(jié)，而c2與s之間就不需要了，所以c2的偏移量為12，算上c2的大小為13，13是不能被4整除的，這樣末尾還得補上3個填充字節(jié)。最后得到sizeof(S3)的值為16。
??? 通過上面的敘述，我們可以得到一個公式：
??? 結(jié)構(gòu)體的大小等于最后一個成員的偏移量加上其大小再加上末尾的填充字節(jié)數(shù)目，即：
sizeof( struct ) = offsetof( last item ) + sizeof( last item ) + sizeof( trailing padding )
?
10.類的sizeof
?
類的sizeof值等于類中成員變量所占用的內(nèi)存字節(jié)數(shù)。如：
****************************************************************
?
class A
{
?public:
???? int b;
???? float c;
???? char d;
};
int main(void)
{
? A object;
? cout << "sizeof(object) is " << sizeof(object) << endl;
? return 0 ;
}
?
***************************************************************
?
?
輸出結(jié)果為12（我的機器上sizeof(float)值為4，字節(jié)對其前面已經(jīng)講過）。
?
不過需要注意的是，如果類中存在靜態(tài)成員變量，結(jié)果又會是什么樣子呢？
?
***************************************************************
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？不對。結(jié)果仍然是12.
因為在程序編譯期間，就已經(jīng)為static變量在靜態(tài)存儲區(qū)域分配了內(nèi)存空間，并且這塊內(nèi)存在程序的整個運行期間都存在。
而每次聲明了類A的一個對象的時候，為該對象在堆上，根據(jù)對象的大小分配內(nèi)存。
?
如果類A中包含成員函數(shù)，那么又會是怎樣的情況呢？看下面的例子
?
*************************************************************
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 ;
}
?
***************************************************************
?
結(jié)果仍為12。
因為只有非靜態(tài)類成員變量在新生成一個object的時候才需要自己的副本。
所以每個非靜態(tài)成員變量在生成新object需要內(nèi)存，而function是不需要的。
?
?
?
?
//
已知1980年1月1日是星期二！
#include
<
iostream.h
>
#include
<
process.h
>
#include
<
string
.h
>
struct
?Date
{
?
int
?year;
?
int
?month;
?
int
?date;
?
int
?day;
?
char
?week[
10
];
}
;
char
?
*
dweek[
7
]
=
{
"
Sun
"
,
"
Mon
"
,
"
Tues
"
,
"
Weds
"
,
"
Thur
"
,
"
Fri
"
,
"
Sat
"
}
;
Date?showday(Date?pd)
{
?
int
?i
=
0
,j
=
0
,k
=
0
,time,score;
?i
=
(pd.year
-
1980
)
*
365
+
(pd.year
-
1980
)
/
4
-
(pd.year
-
1980
)
/
100
+
(pd.year
-
1980
)
/
400
;
?i
=
i
%
7
+
1
;
?k
=
(pd.date
-
1
)
%
7
;?
?
if
((pd.year
%
100
!=
0
)
&&
(pd.year
%
4
==
0
)
||
(pd.year
%
400
==
0
))
????
{
?????
int
?dday1[
12
]
=
{
31
,
29
,
31
,
30
,
31
,
30
,
31
,
31
,
30
,
31
,
30
,
31
}
;
?????
if
(pd.month
==
2
)???
???
{
????????pd.day
=
29
;
?????
if
(pd.date
>
pd.day)
?????????exit(
0
);
???????cout
<<
"
該月的天數(shù)為:
"
<<
pd.day
<<
endl;???
?????}
?????
else
?????
{
????pd.day
=
dday1[pd.month
-
1
];
????
if
(pd.date
>
dday1[pd.month
-
1
])
?????exit(
0
);
????cout
<<
"
該月的天數(shù)為:
"
<<
pd.day
<<
endl;
???}
????
for
(time
=
0
;time
<
pd.month
-
1
;time
++
)
?????j
+=
dday1[time];
??j
=
j
%
7
;???
??score
=
i
+
j
+
k
+
2
;
??
if
(score
<
7
)
????strcpy(pd.week,dweek[score]);?
??
else
??
{
???
while
(score
>=
7
)
???
{
????score
-=
7
;
???}
??strcpy(pd.week,dweek[score]);?
??}
????
??cout
<<
"
該天的星期數(shù)為:
"
<<
pd.week
<<
endl;???
??}
?
????
else
????
{
????
int
????dday2[
12
]
=
{
31
,
28
,
31
,
30
,
31
,
30
,
31
,
31
,
30
,
31
,
30
,
31
}
;
??
if
(pd.month
==
2
)???
???
{
????????pd.day
=
28
;
?????
if
(pd.date
>
pd.day)
?????????exit(
0
);
???????cout
<<
"
該月的天數(shù)為:
"
<<
pd.day
<<
endl;???
?????}
?????
else
?????
{
????pd.day
=
dday2[pd.month
-
1
];
????
if
(pd.date
>
dday2[pd.month
-
1
])
?????exit(
0
);
????cout
<<
"
該月的天數(shù)為:
"
<<
pd.day
<<
endl;
???}
????
for
(time
=
0
;time
<
pd.month
-
1
;time
++
)
?????j
+=
dday2[time];
??j
=
j
%
7
;???
??score
=
i
+
j
+
k
+
2
;
??
if
(score
<
7
)
????strcpy(pd.week,dweek[score]);?
??
else
??
{
???
while
(score
>=
7
)
???
{
????score
-=
7
;
???}
??strcpy(pd.week,dweek[score]);?
??}
????
??cout
<<
"
該天的星期數(shù)為:
"
<<
pd.week
<<
endl;
??}
return
?pd;
}
void
?main()
{
????Date?obymd;
????obymd.year
=
1980
;
????obymd.month
=
1
;
????obymd.date
=
1
;
????strcpy(obymd.week,dweek[
2
]);
????cout
<<
"
請輸入年,月,日:
"
<<
"
?
"
;
????cin
>>
obymd.year
>>
obymd.month
>>
obymd.date;
????showday(obymd);
}