函數指針的聲明和回調的實現

函數指針的聲明和回調的實現

?? 程序員常常需要實現回調。本文將討論函數指針的基本原則并說明如何使用函數指針實現回調。注意這里針對的是普通的函數，不包括完全依賴于不同語法和語義規則的類成員函數（類成員指針將在另文中討論）。

聲明函數指針

?? 回調函數是一個程序員不能顯式調用的函數；通過將回調函數的地址傳給調用者從而實現調用。要實現回調，必須首先定義函數指針。盡管定義的語法有點不可思議，但如果你熟悉函數聲明的一般方法，便會發現函數指針的聲明與函數聲明非常類似。請看下面的例子：

void f()；// 函數原型

上面的語句聲明了一個函數，沒有輸入參數并返回void。那么函數指針的聲明方法如下：

void (*) ();

?? 讓我們來分析一下，左邊圓括弧中的星號是函數指針聲明的關鍵。另外兩個元素是函數的返回類型（void）和由邊圓括弧中的入口參數（本例中參數是空）。注意本例中還沒有創建指針變量-只是聲明了變量類型。目前可以用這個變量類型來創建類型定義名及用sizeof表達式獲得函數指針的大小：

// 獲得函數指針的大小
unsigned psize = sizeof (void (*) ());

// 為函數指針聲明類型定義
typedef void (*pfv) ();

pfv是一個函數指針，它指向的函數沒有輸入參數，返回類行為void。使用這個類型定義名可以隱藏復雜的函數指針語法。

指針變量應該有一個變量名：

void (*p) (); //p是指向某函數的指針

?? p是指向某函數的指針，該函數無輸入參數，返回值的類型為void。左邊圓括弧里星號后的就是指針變量名。有了指針變量便可以賦值，值的內容是署名匹配的函數名和返回類型。例如：

void func()
{
/* do something */
}
p = func;

p的賦值可以不同，但一定要是函數的地址，并且署名和返回類型相同。

傳遞回調函數的地址給調用者

?? 現在可以將p傳遞給另一個函數（調用者）- caller()，它將調用p指向的函數，而此函數名是未知的：

void caller(void(*ptr)())
{
ptr(); /* 調用ptr指向的函數 */
}
void func();
int main()
{
p = func;
caller(p); /* 傳遞函數地址到調用者 */
}

?? 如果賦了不同的值給p（不同函數地址），那么調用者將調用不同地址的函數。賦值可以發生在運行時，這樣使你能實現動態綁定。

調用規范

?? 到目前為止，我們只討論了函數指針及回調而沒有去注意ANSI C/C++的編譯器規范。許多編譯器有幾種調用規范。如在Visual C++中，可以在函數類型前加_cdecl，_stdcall或者_pascal來表示其調用規范（默認為_cdecl）。C++ Builder也支持_fastcall調用規范。調用規范影響編譯器產生的給定函數名，參數傳遞的順序（從右到左或從左到右），堆棧清理責任（調用者或者被調用者）以及參數傳遞機制（堆棧，CPU寄存器等）。

?? 將調用規范看成是函數類型的一部分是很重要的；不能用不兼容的調用規范將地址賦值給函數指針。例如：

// 被調用函數是以int為參數，以int為返回值
__stdcall int callee(int);

// 調用函數以函數指針為參數
void caller( __cdecl int(*ptr)(int));

// 在p中企圖存儲被調用函數地址的非法操作
__cdecl int(*p)(int) = callee; // 出錯

?? 指針p和callee()的類型不兼容，因為它們有不同的調用規范。因此不能將被調用者的地址賦值給指針p，盡管兩者有相同的返回值和參數列。

posted @ 2006-10-27 22:10 深邃者 閱讀(141) | 評論 (0) | 編輯 收藏

對象的動態分配

     摘要: 對象的動態分配（Dynamically Allocated Object） Posted on 2006-08-05 12:55 一秋草木 閱讀(291) 評論(4) ?編輯?收藏收藏至365Key 所屬分類: C++ --> 1 、對象的分類 ...  閱讀全文

posted @ 2006-10-23 19:54 深邃者 閱讀(374) | 評論 (0) | 編輯 收藏

關鍵字

mutable關鍵字

關鍵字mutable是C++中一個不常用的關鍵字,他只能用于類的非靜態和非常量數據成員
我們知道一個對象的狀態由該對象的非靜態數據成員決定,所以隨著數據成員的改變,
對像的狀態也會隨之發生變化!

如果一個類的成員函數被聲明為const類型,表示該函數不會改變對象的狀態,也就是
該函數不會修改類的非靜態數據成員.但是有些時候需要在該類函數中對類的數據成員
進行賦值.這個時候就需要用到mutable關鍵字了

例如:
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;
}

編譯上面的代碼會出現 error C2166: l-value specifies const object的錯誤
說明在const類型的函數中改變了類的非靜態數據成員.

這個時候需要使用mutable來修飾一下要在const成員函數中改變的非靜態數據成員
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;
}

這樣再重新編譯的時候就不會出現錯誤了!

?

?

volatile關鍵字

volatile是c/c++中一個鮮為人知的關鍵字,該關鍵字告訴編譯器不要持有變量的臨時拷貝,它可以適用于基礎類型
如：int,char,long......也適用于C的結構和C++的類。當對結構或者類對象使用volatile修飾的時候，結構或者
類的所有成員都會被視為volatile.

使用volatile并不會否定對CRITICAL_SECTION,Mutex,Event等同步對象的需要
例如：
int i;
i = i + 3;
無論如何，總是會有一小段時間，i會被放在一個寄存器中，因為算術運算只能在寄存器中進行。一般來說，volatitle
關鍵字適用于行與行之間，而不是放在行內。

我們先來實現一個簡單的函數，來觀察一下由編譯器產生出來的匯編代碼中的不足之處，并觀察volatile關鍵字如何修正
這個不足之處。在這個函數體內存在一個busy loop(所謂busy loop也叫做busy waits,是一種高度浪費CPU時間的循環方法)

void getKey(char* pch)
{
?while (*pch == 0)
??;
}

當你在VC開發環境中將最優化選項都關閉之后，編譯這個程序，將獲得以下結果(匯編代碼)
;?????? 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
;}

這段沒有優化的代碼不斷的載入適當的地址，載入地址中的內容，測試結果。效率相當的低，但是結果非常準確

現在我們再來看看將編譯器的所有最優化選項開關都打開以后，重新編譯程序，生成的匯編代碼，和上面的代碼
比較一下有什么不同
;{
?; 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
?;
;}

從代碼的長度就可以看出來，比沒有優化的情況要短的多。需要注意的是編譯器把MOV指令放到了循環之外。這在
單線程中是一個非常好的優化，但是，在多線程應用程序中，如果另一個線程改變了變量的值，則循環永遠不會
結束。被測試的值永遠被放在寄存器中，所以該段代碼在多線程的情況下，存在一個巨大的BUG。解決方法是重新
寫一次getKey函數，并把參數pch聲明為volatile,代碼如下：

void getKey(volatile char* pch)
{
?while (*pch == 0)
??;
}

這次的修改對于非最優化的版本沒有任何影響，下面請看最優化后的結果：

;{
?; 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
?;
;}

這次的修改結果比較完美，地址不會改變，所以地址聲明被移動到循環之外。地址內容是volatile,所以每次循環
之中它不斷的被重新檢查。

把一個const volatile變量作為參數傳遞給函數是合法的。如此的聲明意味著函數不能改變變量的值，但是變量的
值卻可以被另一個線程在任何時間改變掉。

explicit關鍵字

我們在編寫應用程序的時候explicit關鍵字基本上是很少使用,它的作用是"禁止單參數構造函數"被用于自動型別轉換,
其中比較典型的例子就是容器類型,在這種類型的構造函數中你可以將初始長度作為參數傳遞給構造函數.
例如:
你可以聲明這樣一個構造函數
class Array
{
public:
?explicit Array(int size);
?......
};
在這里explicit關鍵字起著至關重要的作用,如果沒有這個關鍵字的話,這個構造函數有能力將int轉換成Array.一旦這種
情況發生,你可以給Array支派一個整數值而不會引起任何的問題,比如:
Array arr;
...
arr = 40;
此時,C++的自動型別轉換會把40轉換成擁有40個元素的Array,并且指派給arr變量,這個結果根本就不是我們想要的結果.如果
我們將構造函數聲明為explicit,上面的賦值操作就會導致編譯器報錯,使我們可以及時發現錯誤.
需要注意的是:explicit同樣也能阻止"以賦值語法進行帶有轉型操作的初始化";
例如:
Array arr(40);//正確
Array arr = 40;//錯誤

看一下以下兩種操作:
X x;
Y y(x);//顯式類型轉換
另一種
X x;
Y y = x;//隱式類型轉換

這兩種操作存在一個小小的差別,第一種方式式通過顯式類型轉換,根據型別x產生了型別Y的新對象;第二種方式通過隱式轉換
產生了一個型別Y的新對象.
explicit關鍵字的應用主要就是上面所說的構造函數定義種,參考該關鍵字的應用可以看看STL源代碼,其中大量使用了該關鍵字

?

__based關鍵字

該關鍵字主要用來解決一些和共享內存有關的問題,它允許指針被定義為從某一點開始算的32位偏移值,而不是內存種的絕對位置
舉個例子:

typedef struct tagDEMOSTRUCT {
?int a;
?char sz[10];
} DEMOSTRUCT, * PDEMOSTRUCT;

HANDLE hFileMapping = CreateFileMapping(...);
LPVOID lpShare = (LPDWORD)MapViewOfFile(...);

DEMOSTRUCT __based(lpShare)* lpDemo;

上面的例子聲明了一個指針lpDemo,內部儲存的是從lpShare開始的偏移值,也就是lpHead是以lpShare為基準的偏移值.
上面的例子種的DEMOSTRUCT只是隨便定義的一個結構,用來代表任意的結構.

雖然__based指針使用起來非常容易,但是,你必須在效率上付出一定的代價.每當你用__based指針處理數據,CPU都必須
為它加上基地址,才能指向真正的位置.

在這里我只是介紹了幾個并不時很常見的關鍵字的意義即用法,其他那些常見的關鍵字介紹他們的文章已經不少了在這里
就不再一一介紹了.希望這些內容能對大家有一定的幫助!

posted @ 2006-10-22 16:07 深邃者 閱讀(175) | 評論 (0) | 編輯 收藏

結構體的對齊

由一道面試題來看 Struct 的對界

?

本文節選自宋寶華的C/C++的struct深層探索一文，本人對其所描述的struct對齊比較喜歡，為此轉來與大家分享，原文見http://blog.donews.com/21cnbao/archive/2005/09/08/544877.aspx

?

Intel 、微軟等公司曾經出過一道類似的面試題：

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. }

問程序的輸入結果是什么？

答案是：

8

16

4

不明白？還是不明白？下面一一道來：

1 、 自然對界

struct 是一種復合數據類型，其構成元素既可以是基本數據類型（如 int 、 long 、 float 等）的變量，也可以是一些復合數據類型（如 array 、 struct 、 union 等）的數據單元。對于結構體，編譯器會自動進行成員變量的對齊，以提高運算效率。缺省情況下，編譯器為結構體的每個成員按其自然對界（ natural alignment ）條件分配空間。各個成員按照它們被聲明的順序在內存中順序存儲，第一個成員的地址和整個結構的地址相同。

自然對界 (natural alignment) 即默認對齊方式，是指按結構體的成員中 size 最大的成員對齊。

例如：

struct naturalalign

{

char a;

short b;

char c;

};

在上述結構體中， size 最大的是 short ，其長度為 2 字節，因而結構體中的 char 成員 a 、 c 都以 2 為單位對齊， sizeof(naturalalign) 的結果等于 6 ；

如果改為：

struct naturalalign

{

char a;

int b;

char c;

};

其結果顯然為 12 。

?

2 、 指定對界

一般地，可以通過下面的方法來改變缺省的對界條件：

· 使用偽指令 #pragma pack (n) ，編譯器將按照 n 個字節對齊；

· 使用偽指令 #pragma pack () ，取消自定義字節對齊方式。

注意：如果 #pragma pack (n) 中指定的 n 大于結構體中最大成員的 size ，則其不起作用，結構體仍然按照 size 最大的成員進行對界。

例如：

#pragma pack (n)

struct naturalalign

{

char a;

int b;

char c;

};

#pragma pack ()

當 n 為 4 、 8 、 16 時，其對齊方式均一樣， sizeof(naturalalign) 的結果都等于 12 。而當 n 為 2 時，其發揮了作用，使得 sizeof(naturalalign) 的結果為 8 。

posted @ 2006-10-21 13:21 深邃者 閱讀(209) | 評論 (0) | 編輯 收藏

結構體高級特性

     摘要: C/C++ 結構體的一個高級特性 ―― 指定成員的位數 ...  閱讀全文

posted @ 2006-10-21 13:06 深邃者 閱讀(428) | 評論 (0) | 編輯 收藏

關于局部與全局及靜態的關系

1.在一個函數內部定義的變量是內部變量，它只在本函數范圍內有效，在此函數外面是不能使用這個變量，稱之為 "局部變量"。形式參數也屬于局部變量。在函數中的一個程序塊（如某個復合語句｛...｝）定義的局部變量只在這個程序塊中有效，出了程序塊后就無效。
2.有時希望函數中的局部變量的值在函數調用之后不消失而保留原值，在下一次該函數調用時該變量已有值，這時就該制定該局部變量為"靜態局部變量"，用static加以說明。
3.在函數之外定義的變量稱之為全局變量，全局變量可以為本文件中其他函數所共用，其有效范圍為：從定義變量開始到本源文件結束。如果在定義點之前的函數想應用該全局變量，則應該在該函數中使用關鍵字 extern作外部變量說明，表示該變量在函數外部定義在函數內部可以使用它。如果在同一個源文件中，全局變量和局部變量同名，則在局部變量作用范圍內，全局變量不起作用。如果在其它文件中要引用該文件的全局變量，則需要在應用它的文件中，用extern作說明。
4.所謂靜態全局變量，就是希望某些全局變量只限定于被本文件引用，而不被其它文件引用，這時可以在定義全局變量的時候在前面加一個static說明，

?5 按存儲區域分，全局變量、靜態全局變量和靜態局部變量都存放在內存的靜態存儲區域，局部變量存放在內存的棧區。
??6?按作用域分，全局變量在整個工程文件內都有效；靜態全局變量只在定義它的文件內有效；靜態局部變量只在定義它的函數內有效，只是程序僅分配一次內存，函數返回后，該變量不會消失；局部變量在定義它的函數內有效，但是函數返回后失效。
??7?全局變量和靜態變量如果沒有手工初始化，則由編譯器初始化為0。局部變量的值不可知。
8 舉個例子：
int a;??/*全局*/
static int b;??/*靜態全局*/
int main()
{
}
這段代碼如果是寫在file.c里面的，那么file2.c就不能調用b;
但是file2.c中可以通過聲明外部變量extent a;

9.靜態全局變量 　　全局變量(外部變量)的說明之前再冠以static 就構成了靜態的全局變量。全局變量本身就是靜態存儲方式， 靜態全局變量當然也是靜態存儲方式。 這兩者在存儲方式上并無不同。這兩者的區別雖在于非靜態全局變量的作用域是整個源程序， 當一個源程序由多個源文件組成時，非靜態的全局變量在各個源文件中都是有效的。 而靜態全局變量則限制了其作用域， 即只在定義該變量的源文件內有效， 在同一源程序的其它源文件中不能使用它。由于靜態全局變量的作用域局限于一個源文件內，只能為該源文件內的函數公用， 因此可以避免在其它源文件中引起錯誤。從以上分析可以看出， 把局部變量改變為靜態變量后是改變了它的存儲方式即改變了它的生存期。把全局變量改變為靜態變量后是改變了它的作用域， 限制了它 的使用范圍。因此static 這個說明符在不同的地方所起的作用是不同的。應予以注意。

10 代碼
//test.cpp
＃i nclude?<iostream.h>
extern?int?a;//變量聲明，不是定義
static?int?b=5;
void?func1()
{
??cout<<b<<endl<<a<<endl;//結果為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();
}
輸出結果為
5
20
1
2

posted @ 2006-09-10 12:11 深邃者 閱讀(392) | 評論 (0) | 編輯 收藏

關于sizeof（）

這篇文章轉載于 馬嘉楠 ，個人認為那位作者寫得有可取之處。

1. 定義：
??? 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.

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

typedef unsigned int size_t;

??? 世上編譯器林林總總，但作為一個規范，它們都會保證char、signed char和unsigned char的sizeof值為1，畢竟char是我們編程能用的最小數據類型。

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代替，為求形式統一以及減少我們大腦的負擔，第2種寫法，忘掉它吧！

實際上，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() has been called.\n");
????return 'a';
}
int main()
{
????size_t sz = sizeof( foo() );?? // foo() 的返回值類型為char，所以sz = sizeof(char)，但函數foo()并不會被調用
????printf("sizeof( foo() ) = %d\n", sz);
}

*********************************************************

C99標準規定，函數、不能確定類型的表達式以及位域（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的計算發生在編譯時刻，所以它可以被當作常量表達式使用。如：

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是在編譯期執行的，這樣不會帶來錯誤，讓程序的可移植性強些。

4. 基本數據類型的sizeof

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

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

5. 指針變量的sizeof

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

*********************************************************

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就能傳遞各種復雜的消息結構（使用指向結構體的指針）。

6. 數組的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 );??? // 總長度/單個元素的長度
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的值時已經意識到c3答錯了，是的，c3!=3。

這里函數參數a3已不再是數組類型，而是蛻變成指針。相當于char* a3，為什么仔細想想就不難明白。

我們調用函數foo1時，程序會在棧上分配一個大小為3的數組嗎？不會！

數組是“傳址”的，調用者只需將實參的地址傳遞過去，所以a3自然為指針類型（char*），c3的值也就為4。

7.string的sizeof
一個string的大小與它所指向的字符串的長度無關。

*********************************************************
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;
*********************************************************

輸出結果為：
st1： 28
st2： 28
st3： 28
ps： 4
*ps： 28
*********************************************************
對于不同的STL，String類的結構定義會有所不同
所以不同的工具，例如VC++，和.NET，結果會有所不同，
在VC++6.0中（我的機器）結果是16
在.NET2003中結果是28
但是對于同一個編譯器，那么它的結果都是一定的


8.引用的sizeof

sizeof操作符應用在引用類型上的時候，返回的是包含被引用對象所需的內存長度（即被引用對象的大小）

*********************************************************
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;
*********************************************************

輸出結果為：
short： 2
short*： 4
short&： 2
short[4]： 8
int&： 4


9. 結構體的sizeof

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

struct S1
{
??? char c;
??? int i;
};

問sizeof(s1)等于多少？

聰明的你開始思考了，char占1個字節，int占4個字節，那么加起來就應該是5。

是這樣嗎？

你在你機器上試過了嗎？

也許你是對的，但很可能你是錯的！

VC6中按默認設置得到的結果為8。

??? Why？為什么受傷的總是我？

請不要沮喪，我們來好好琢磨一下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) 結構體變量的首地址能夠被其最寬基本類型成員的大小所整除；
??? 2) 結構體每個成員相對于結構體首地址的偏移量（offset）都是成員大小的整數倍，如有需要編譯器會在成員之間加上填充字節（internal adding）；
??? 3) 結構體的總大小為結構體最寬基本類型成員大小的整數倍，如有需要編譯器會在最末一個成員之后加上填充字節（trailing padding）。

??? 對于上面的準則，有幾點需要說明：
1)?前面不是說結構體成員的地址是其大小的整數倍，怎么又說到偏移量了呢？

因為有了第1點存在，所以我們就可以只考慮成員的偏移量，這樣思考起來簡單。想想為什么。

結構體某個成員相對于結構體首地址的偏移量可以通過宏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這樣的內置數據類型。這里所說的“數據寬度”就是指其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( last item ) + sizeof( last item ) + sizeof( trailing padding )

?

int main(void)
{
? A object;
? cout << "sizeof(object) is " << sizeof(object) << endl;
? return 0 ;
}

?

***************************************************************

int main()
{

? A object;
??cout << "sizeof(object) is " << sizeof(object) << endl;
? return 0 ;
}

因為在程序編譯期間，就已經為static變量在靜態存儲區域分配了內存空間，并且這塊內存在程序的整個運行期間都存在。

而每次聲明了類A的一個對象的時候，為該對象在堆上，根據對象的大小分配內存。

posted @ 2006-09-05 12:21 深邃者 閱讀(291) | 評論 (1) | 編輯 收藏

輸出程序注釋行

?

posted @ 2006-05-09 22:08 深邃者 閱讀(379) | 評論 (1) | 編輯 收藏

密碼輸入匹配問題

?

posted @ 2006-05-09 22:06 深邃者 閱讀(249) | 評論 (0) | 編輯 收藏

萬年歷

?

posted @ 2006-05-09 22:03 深邃者 閱讀(251) | 評論 (0) | 編輯 收藏