From 2008精選

函數(shù)指針教程 原版：http://www.newty.de/fpt/index.html
譯者：Lymons Lau

1.1 什么是函數(shù)指針 ?

1.2  開場例子或者怎么替換Switch語句

函數(shù)指針提供了一些極其有趣，有效和絕妙的編程技術。你能用它代替switch/if語句來實現(xiàn)你自己的晚綁定（late-binding）或者作為回調(diào)（callback）來使用。不幸的是–可能由于它的語法比較復雜–幾乎所有的電腦書籍和文檔上都講解的不多。即便如此，它們也只是做了相當簡單和膚淺的說明。而對于函數(shù)指針你只需要明白它是什么以及它的語法，因為它和一般的指針比起來從來不用關心內(nèi)存的分配和釋放，所以它被使用的時候是不易產(chǎn)生錯誤的。但你要注意的是: 要時常問自己是否真的需要函數(shù)指針。因為雖然用它來實現(xiàn)晚綁定也很漂亮，但用既存的C++數(shù)據(jù)結(jié)構(gòu)的話會使代碼更可讀和更簡潔。另外，晚綁定的一方面實際上就是運行期（runtime）: 如果你調(diào)用了一個虛擬函數(shù)，你的程序會根據(jù)一個存儲所有函數(shù)的虛擬表（V-Table）自己來確定到底真正調(diào)用的是哪一個。這就要花費一些時間而用函數(shù)指針代替虛擬函數(shù)的話有可能會節(jié)省一些時間。BTW: 現(xiàn)代的編譯器在這方面都做得非常好！就那我的Borland編譯器來說這個時間就比調(diào)用一次虛擬函數(shù)能節(jié)省2%。

注：晚捆綁(late binding)可能來自c++的術語，也稱為動態(tài)捆綁(dynamic binding)，它主要是來實現(xiàn)多態(tài)機制。既是一種在運行時動態(tài)確定語義的機制。

1.1 什么是函數(shù)指針？

函數(shù)指針就是一個指針，也就是一個指向函數(shù)地址的變量。你必須注意的是，一個正在運行的程序在主內(nèi)存內(nèi)獲得一段固定的空間，并且編譯出來的可執(zhí)行程序代碼和代碼中的變量都駐留在這段內(nèi)存里。而在這個程序代碼里的一個函數(shù)無非就是一個地址。重要的是你只要知道或者說你的編譯器/處理器，怎么來解釋一個指針指向的那段內(nèi)存中的內(nèi)容。

1.2 開場例子和怎么來代替一個Switch-語句

當你想要在程序中的某一個地方調(diào)用函數(shù)DoIt()的時候, 你只需要在源代碼的這個地方放上函數(shù)DoIt()的調(diào)用即可.那么，在編譯完這段代碼后當你的程序執(zhí)行到這個地方時這個DoIt()函數(shù)就會被調(diào)用.好像看上來一切都ok.但是,如果你不知道在代碼的構(gòu)建時期（build-time）哪一個函數(shù)將要被調(diào)用的話你能做什么呢?在運行期你要是決定哪一個函數(shù)要被調(diào)用的話那你需要做什么呢?這時你可能會使用一個回調(diào)函數(shù)（Callback-Function）或者你想在一堆函數(shù)列表中選擇其中的一個。然而，你也能使用switch語句，在想要調(diào)用函數(shù)的地方使用不同的分支來解決這個問題。但是，這里我們講述的是另一個方式：就是使用函數(shù)指針！

在下面的例子中，我們能看到它的主要處理就是執(zhí)行一個算術操作（共有4個算術操作）。首先是使用了switch語句來實現(xiàn)，另外還使用了函數(shù)指針處理這個調(diào)用。這僅僅是個處理簡單的例子，我想可能正常情況下沒有人會使用函數(shù)指針來這么作吧;-)

 
//------------------------------------------------------------------------------------
// 1.2 開場例子和怎么替代一個Switch-語句
// 任務:通過字符'+', '-', '*' 和 '/'
//       選擇執(zhí)行一個基本的算術操作. 

// 四個算術操作  使用swicth或者一個函數(shù)指針
// 在運行期選擇這些函數(shù)中的一個
float Plus    (float a, float b) { return a+b; }
float Minus   (float a, float b) { return a-b; }
float Multiply(float a, float b) { return a*b; }
float Divide  (float a, float b) { return a/b; }


// switch-語句的解決方案 - <opCode> 要選擇那一個函數(shù)的操作碼
void Switch(float a, float b, char opCode)
{
   float result;

   // 執(zhí)行操作
   switch(opCode)
   {
      case '+' : result = Plus     (a, b); break;
      case '-' : result = Minus    (a, b); break;
      case '*' : result = Multiply (a, b); break;
      case '/' : result = Divide   (a, b); break;
   }

   cout << "Switch: 2+5=" << result << endl;         // 顯示結(jié)果
}
 

// 函數(shù)指針的解決方案 - <pt2Func> 是一個指向帶有兩個float型參數(shù)
// 和float型返回值的函數(shù). 這個函數(shù)指針“指定”了那一個函數(shù)將被執(zhí)行.
void Switch_With_Function_Pointer(float a, float b, float (*pt2Func)(float, float))
{
   float result = pt2Func(a, b);    // 調(diào)用函數(shù)指針

   cout << "Switch replaced by function pointer: 2-5=";  // 顯示結(jié)果
   cout << result << endl;
}


// 執(zhí)行樣例代碼
void Replace_A_Switch()
{
   cout << endl << "Executing function 'Replace_A_Switch'" << endl;

   Switch(2, 5, /* '+' 指定了 'Plus'函數(shù)將被執(zhí)行 */ '+');
   Switch_With_Function_Pointer(2, 5, /* 指向'Minus'函數(shù)的指針 */ &Minus);
}

提示：一個函數(shù)指針總是使用一個特定的標識來指向一個函數(shù)！然而，一旦你想要用一個函數(shù)指針指向很多函數(shù)，那的保證這些函數(shù)擁有相同的參數(shù)和返回值。

2.  C 和 C++ 函數(shù)指針語法

2.1  定義函數(shù)指針

在語法上, 函數(shù)指針有兩種不同的類型: 一種是指向普通函數(shù)或靜態(tài)C++成員函數(shù)的指針. 另一種是指向非靜態(tài)的C++成員函數(shù). 它們之間基本的區(qū)別就是所有指向非靜態(tài)成員函數(shù)的函數(shù)指針需要一個隱含參數(shù): 成員函數(shù)所屬類的實例. 經(jīng)常要注意的是: 這兩種類型之間的函數(shù)指針是相互不兼容的.

因為函數(shù)指針無非就是一個變量, 所以它的定義也跟正常變量一樣定義. 在下面的例子里，我們定義了3個函數(shù)指針，分別是pt2Function, pt2Member 和 pt2ConstMember. 它們指向的函數(shù)的參數(shù)（一個float和兩個char）和返回值都相同. 在C++ 的例子里，指向的函數(shù)都是必須是類TMyClass的成員函數(shù).

2.2  調(diào)用規(guī)約

一般的情況下你不用考慮一個函數(shù)的調(diào)用規(guī)約(calling convention): 如果你沒有指定另外的規(guī)約的話編譯器是把__cdecl 作為默認的規(guī)約. 如果你想要了解的更多的話, 那就繼續(xù)往后讀吧... 我們說的這個調(diào)用規(guī)約就是告訴編譯器做一些時而，比如怎么去傳遞參數(shù)或者怎么去生成函數(shù)的名字. 某些例子里還有其它的調(diào)用規(guī)約如__stdcall, __pascal 和 __fastcall. 這些調(diào)用規(guī)約實際上是屬于函數(shù)的標識(signature): 那么函數(shù)與和自己有些不同調(diào)用規(guī)約的函數(shù)指針之間是相互不兼容的! 對于Borland 和Microsoft 的編譯器規(guī)定你要指定的調(diào)用規(guī)約應該放在返回值和函數(shù)或函數(shù)名之間. 而對于GNU GCC 的編譯器是使用 __attribute__ 關鍵字: 也就是通過關鍵字__attribute__把調(diào)用規(guī)約寫在函數(shù)定義的后面并用雙括號把它括上. 如果有誰還知道更多的調(diào)用規(guī)約的話: 請讓我知道;-) 另外，你想要知道函數(shù)調(diào)用在編譯規(guī)約下是怎么工作的，請閱讀Paul Carter的 PC Assembly Tutorial Subprograms 這一章節(jié).

2.3  給函數(shù)指針賦值

把一個函數(shù)的地址賦給一個函數(shù)指針是非常容易. 你只要知道函數(shù)和成員函數(shù)的名字. 盡管大多數(shù)編譯器需要在函數(shù)名的前面加上一個地址符& 但為了代碼的可移植行你應該這么做. 當指向成員函數(shù)的時候你還需要在該函數(shù)前面加上類名和域操作符(::). 你還要保證, 在你賦值的地方已經(jīng)被允許訪問該函數(shù).

2.4  比較函數(shù)指針

對于函數(shù)指針你也能像正常寫法一樣使用比較操作符(==, !=). 在下面的例子里，檢查pt2Function 和pt2Member 是否是真的等于函數(shù)DoIt 和 TMyClass::DoMore 的地址. 相當?shù)臅r候輸出一段字符串.

2.5  通過函數(shù)指針調(diào)用函數(shù)

在C語言里你能顯示地使用解引用操作符*來調(diào)用一個函數(shù). 還可以直接使用函數(shù)指針來代替你要調(diào)用函數(shù)的名字. 在 C++ 里面.* 和 ->* 這兩個操作符可以分別與類事例在一起使用來調(diào)用這些類的成員函數(shù)(非靜態(tài)). 如果這個調(diào)用發(fā)生這些類的成員函數(shù)里則可以使用this-指針.

2.6  怎么把一個函數(shù)指針作為參數(shù)進行傳遞?

你能把一個函數(shù)指針作為一個函數(shù)的調(diào)用參數(shù). 下列代碼顯示了怎么傳遞一個函數(shù)指針（返回值為int型，第一個參數(shù)為float型，第二，三個參數(shù)都為char型）:

2.7  怎么返回函數(shù)指針 ?

把一個函數(shù)指針作為返回值需要一個小技巧. 就像下面的例子一樣有兩種方法來返回一個帶有兩個參數(shù)和返回值的函數(shù)指針. 如果你想要返回一個指向成員函數(shù)的指針你只需改一下函數(shù)指針的定義/聲明.

2.8  怎么使用函數(shù)指針數(shù)組?

操作函數(shù)指針數(shù)組是非常有意思的事情. 這使得用一個索引來選擇一個函數(shù)指針變得可能. 這個語法表示起來較困難,常常導致混淆. 下面有兩種方法可以在C 和C++里定義并使用一個函數(shù)指針數(shù)組. 第一個方法是使用typedef, 第二個方法是直接定一個數(shù)組. 愿意使用那種方法完全取決于你.

3.  怎么在 C 和 C++中實現(xiàn)回調(diào)

3.1  回調(diào)函數(shù)的概念

在回調(diào)函數(shù)的概念中當然少不了函數(shù)指針這東西. 如果你不知道怎么使用函數(shù)指針的話你可以去看一下函數(shù)指針簡介 這一章. 我將使用著名的排序函數(shù)qsort來給大家解釋回調(diào)函數(shù)的概念. 這個函數(shù)可以根據(jù)用戶指定的排序方式來排列一個區(qū)域中的很多項目之間的順序. 這個區(qū)域中包含的項目可以是任何類型; 它是通過void-類型的指針被傳遞到這個排序函數(shù)里. 另外該類型項目的大小和這個區(qū)域中項目的數(shù)量也要被傳遞到排序函數(shù)里.現(xiàn)在的問題是: 這個排序函數(shù)在不知道項目類型的任何信息的情況下怎么實現(xiàn)排序功能的呢? 這個答案非常簡單: 就是這個函數(shù)要接收一個指向帶有兩個參數(shù)是void型項目指針的比較函數(shù)的函數(shù)指針, 這個比較函數(shù)則是來估算兩個項目之間的順序并返回一個int型的結(jié)果代碼. 因此每一次這個排序算法需要決定兩個項目之間的順序時則僅僅是通過函數(shù)指針來調(diào)用這個比較函數(shù)即可: 這就是回調(diào)!

3.2  怎么在C里實現(xiàn)回調(diào)?

下面是函數(shù) qsort 的聲明:

   void qsort(void* field, size_t nElements, size_t sizeOfAnElement,

                    int(_USERENTRY *cmpFunc)(const void*, const void*));

field 指向要被排序的那個域中的第一個元素, nElements 是這個域里的項目數(shù)量, sizeOfAnElement 則是用字節(jié)表示的一個項目的大小并且 cmpFunc 是指向比較函數(shù)的函數(shù)指針. 這個比較函數(shù)帶有兩個void-型指針的參數(shù)并返回一個型的返回值int. 在函數(shù)的定義里怎么把函數(shù)指針作為一個參數(shù)來使用的語法看起來有一些陌生. 只要看看, 怎么定義一個函數(shù)指針這一章你就能發(fā)現(xiàn)它完全就是相同的. 執(zhí)行一個 回調(diào)就像普通函數(shù)被調(diào)用那樣簡單: 你只需要使用函數(shù)指針的名字而不是那個函數(shù)的名字. 就像下面顯示的那樣. 注意: 下面的代碼中除了函數(shù)指針所有的參數(shù)都被省略了因為我們只是關注跟函數(shù)指針相關的事情.

 
   void qsort(  , int(_USERENTRY *cmpFunc)(const void*, const void*))
   {
      /* 排序算法  - 注意: item1 和 item2 是 void-型的指針 */ 

      int bigger=cmpFunc(item1, item2);  // 做一個回調(diào) 

      /* 使用上面的結(jié)果 */
   }

3.3  qsort的使用例子

在下面的例子里排序 floats 型的項目.

 
 //-----------------------------------------------------------------------------------------
   // 3.3 通過qsort排序函數(shù)的方法在C 中實現(xiàn)回調(diào)

   #include <stdlib.h>        // due to:  qsort
   #include <time.h>          // randomize
   #include <stdio.h>         // printf

   // 排序算法的比較函數(shù)
   // 兩個被比較的項目的類型都是 void-指針, 先作轉(zhuǎn)換后作比較
   int CmpFunc(const void* _a, const void* _b)
   {
      // you've got to explicitly cast to the correct type
      const float* a = (const float*) _a;
      const float* b = (const float*) _b;

      if(*a > *b) return 1;              // first item is bigger than the second one -> return 1
      else
         if(*a == *b) return  0;         // equality -> return 0
         else         return -1;         // second item is bigger than the first one -> return -1
   }

   // 使用qsort()的例子
   void QSortExample()
   {
      float field[100];

      ::randomize();                     // 初始化隨機數(shù)生成器
      for(int c=0;c<100;c++)             // 給域中的每個元素設定隨機值
         field[c]=random(99);

      // 用 qsort()進行排序
      qsort((void*) field, /*項目的數(shù)量*/ 100, /*一個項目的大小*/ sizeof(field[0]),
            /*比較函數(shù)*/ CmpFunc);

      // 排完序后顯示前10個元素
      printf("The first ten elements of the sorted field are \n");
      for(int c=0;c<10;c++)
         printf("element #%d contains %.0f\n", c+1, field[c]);
      printf("\n");
   }

3.4  實現(xiàn) C++ 靜態(tài)成員函數(shù)的回調(diào)?

這跟在C里的實現(xiàn)是完全一樣的. 靜態(tài)成員函數(shù)不需要調(diào)用類對象并就像C函數(shù)一樣擁有相同標識，相同的調(diào)用規(guī)約，調(diào)用參數(shù)以及返回值.

3.5 實現(xiàn) C++ 非靜態(tài)成員函數(shù)的回調(diào)?

封裝方法

指向非靜態(tài)成員的指針和普通的C指針是不一樣的，因為它們需要傳遞一個類對象的this-指針. 而且普通的函數(shù)指針和非靜態(tài)成員函數(shù)有些不同并存在不兼容的標識(signatures)! 如果你想要回調(diào)一個指定類的成員函數(shù)那你得把你的代碼從普通的函數(shù)指針改成一個指向成員函數(shù)的指針. 但是如果你想要回調(diào)一個任意類的非靜態(tài)成員函數(shù)那你能怎么做呢? 這有一點兒困難. 你需要寫一個靜態(tài)的成員函數(shù)作為包裝函數(shù). 一個靜態(tài)成員函數(shù)擁有和C函數(shù)一樣的標識! 然后你要把要調(diào)用的成員函數(shù)的類對象指針強轉(zhuǎn)為void* 并作為附加參數(shù)或者全局變量傳遞到包裝函數(shù)里. 有一點比較重要，如果你使用全局變量時你必須得保證這個指針總是指向一個正確的類對象! 當然你也得為成員函數(shù)傳遞那些調(diào)用參數(shù). 這個包裝函數(shù)把void指針強轉(zhuǎn)為對應類的實例的指針并調(diào)用這個成員函數(shù). 在后面你能看到兩個例子.

例 A: 作為附加參數(shù)來傳遞類實例的指針

函數(shù) DoItA 利用TClassA類（包含有一個回調(diào)）的對象作一些事情. 因此指向靜態(tài)包裝函數(shù)TClassA::Wrapper_To_Call_Display的指針要被傳遞到函數(shù)DoItA中. 這個包裝函數(shù)是一個回調(diào)函數(shù). 你也能隨便寫一個類似于TClassA的類并在函數(shù)DoItA中使用當然前提是那些類立提供了包裝函數(shù). 注意:利用回調(diào)函數(shù)作為接口的設計方案會比下面使用全局變量的那個方案要有用的多.

例B: 把類實例的指針作為全局變量

函數(shù)DoItB利用TClassA類（包含有一個回調(diào)）的對象作一些事情. 因此指向靜態(tài)包裝函數(shù)TClassB::Wrapper_To_Call_Display的指針要被傳遞到函數(shù)DoItA中. 這個包裝函數(shù)是一個回調(diào)函數(shù). 你也能隨便寫一個類似于TClassA的類并在函數(shù)DoItA中使用當然前提是那些類立提供了包裝函數(shù). 注意: 這個方案在已經(jīng)存在的回調(diào)接口不會被改變的前提下才會比較有用，但因為使用全局變量可能會非常危險而且還可能到使嚴重錯誤所以這并不是一個很好的方案.

 
  //-----------------------------------------------------------------------------------------
   // 3.5 例B: 使用全局變量回調(diào)成員函數(shù)
   // 任務: 函數(shù) 'DoItB'中回調(diào)成員函數(shù)'Display'. 因此要使用包裝函數(shù)
   //       'Wrapper_To_Call_Display'..

   #include <iostream.h>   // due to:   cout

   void* pt2Object;        // 一個可以指向任意類的全局變量

   class TClassB
   {
   public:

      void Display(const char* text) { cout << text << endl; };
      static void Wrapper_To_Call_Display(char* text);

      /* more of TClassB */
   };


   // 靜態(tài)成員函數(shù)能回調(diào)成員函數(shù) Display()
   void TClassB::Wrapper_To_Call_Display(char* string)
   {
       // 顯示地將全局變量 <pt2Object> 強轉(zhuǎn)成類TClassB的指針
       // 警告: <pt2Object> 必須指向一個有效的類對象!
       TClassB* mySelf = (TClassB*) pt2Object;
 

       // call member
       mySelf->Display(string);
   }


   // 隱含地做回調(diào)
   // 注意: 當然這個函數(shù)也能作為成員函數(shù)
   void DoItB(void (*pt2Function)(char* text))
   {
      /* do something */

      pt2Function("hi, i'm calling back using a global ;-)");   // make callback
   }

   // execute example code
   void Callback_Using_Global()
   {
      // 1.  TClassB類對象的初始化
      TClassB objB;


      // 2. 對在靜態(tài)包裝函數(shù)中要使用的全局變量進行賦值
      // 重要: 一定不要忘記作這一步
      pt2Object = (void*) &objB;


      // 3. call 'DoItB' for <objB>
      DoItB(TClassB::Wrapper_To_Call_Display);
   }

4. 封裝C 和 C++函數(shù)指針的仿函數(shù)

4.1  什么是仿函數(shù) ?

仿函數(shù)是一個具有狀態(tài)的函數(shù). 在C++ 你能看到它們作為一個用一到兩個私有成員來存儲這些狀態(tài)的類來出現(xiàn)，并利用重載的操作符()來執(zhí)行本身的操作. 仿函數(shù)是利用模版（templates）和多態(tài)(polymorphism）的概念來封裝C 和 C++ 的函數(shù)指針. 你能構(gòu)建一個任意類的成員函數(shù)的指針列表并通過相同的接口來調(diào)用它們，但不會干擾它們的類或者一個實例的指針的需求. 僅僅是要求所有的函數(shù)要保持相同的返回類型和調(diào)用參數(shù). 有時候仿函數(shù)通常會被稱為閉包(closures). 你也能用仿函數(shù)來實現(xiàn)回調(diào).

4.2  怎么實現(xiàn)仿函數(shù) ?

首先你需要一個提供了一個叫Call的虛函數(shù)的基類TFunctor或者一個能調(diào)用成員函數(shù)的虛擬重載操作符 ().是選擇重載操作符還是函數(shù)Call當然是隨便你自己的喜好了. 從這個基類你能派生一個模版類 TSpecificFunctor ，在構(gòu)造函數(shù)里用一個對象的指針和一個函數(shù)指針來初始化.這個派生類重載基類中的函數(shù)Call并/或操作符(): 在這個重載的版本里，你能利用存儲的函數(shù)指針和類對象的指針來調(diào)用成員函數(shù). 如果你忘了怎么去使用函數(shù)指針你可以參考章節(jié)函數(shù)指針簡介.

 
  //-----------------------------------------------------------------------------------------
   // 4.2 怎么實現(xiàn)仿函數(shù)

   // 抽象基類
   class TFunctor
   {
   public:

      // 兩個用來調(diào)用成員函數(shù)的虛函數(shù)
      // 派生類將使用函數(shù)指針和類對象指針來實現(xiàn)函數(shù)調(diào)用
      virtual void operator()(const char* string)=0;  // call using operator
      virtual void Call(const char* string)=0;        // call using function
   };

   // 派生模版類
   template <class TClass> class TSpecificFunctor : public TFunctor
   {
   private:
      void (TClass::*fpt)(const char*);   // pointer to member function
      TClass* pt2Object;                  // pointer to object

   public:

      // 構(gòu)造函數(shù)- 把類對象指針和函數(shù)指針
      // 存儲在兩個私有變量中
      TSpecificFunctor(TClass* _pt2Object, void(TClass::*_fpt)(const char*))
         { pt2Object = _pt2Object;  fpt=_fpt; };

      // 重載操作符 "()"
      virtual void operator()(const char* string)
       { (*pt2Object.*fpt)(string);};              // execute member function

      // 重載函數(shù) "Call"
      virtual void Call(const char* string)
        { (*pt2Object.*fpt)(string);};             // execute member function
   };

4.3  仿函數(shù)的使用列

在下面的例子里我們有兩個類，包括返回值是(void)和參數(shù)為(const char*)的函數(shù)Display的一個簡單實現(xiàn).這里我們創(chuàng)建兩個TFunctor類的指針數(shù)組并且用封裝了類對象指針和TClassA ，TClassB的成員函數(shù)指針的TSpecificFunctor類來初始化這個數(shù)組中的元素. 而后我們使用仿函數(shù)數(shù)組來分別調(diào)用這兩個成員函數(shù). 類對象并不直接調(diào)用函數(shù)但你得保證你的操作不能干擾這兩個類的操作!

   //-----------------------------------------------------------------------------------------
   // 4.3 仿函數(shù)的使用例子

   // 類A
   class TClassA{
   public:

      TClassA(){};
      void Display(const char* text) { cout << text << endl; };

      /* more of TClassA */
   };

   // 類 B
   class TClassB{
   public:

      TClassB(){};
      void Display(const char* text) { cout << text << endl; };

      /* more of TClassB */
   };

   // 主程序
   int main(int /*argc*/, char* /*argv[]*/)
   {
      // 1. TClassA 和TClassB的實例
      TClassA objA;
      TClassB objB;

      // 2. 實例化TSpecificFunctor 對象 
      //    a ) 封裝指向TClassA類成員的函數(shù)指針的仿函數(shù)
      TSpecificFunctor<TClassA> specFuncA(&objA, &TClassA::Display);

      //    b) 封裝指向TClassB類成員的函數(shù)指針的仿函數(shù)
      TSpecificFunctor<TClassB> specFuncB(&objB, &TClassB::Display);
 

      // 3. 聲明基類TFunctor指針的數(shù)組, 并初始化
      TFunctor* vTable[] = { &specFuncA, &specFuncB };


      // 4. 不需要類對象就可以調(diào)用成員函數(shù)
      vTable[0]->Call("TClassA::Display called!");        // via function "Call"
      (*vTable[1])   ("TClassB::Display called!");        // via operator "()"


      // hit enter to terminate
      cout << endl << "Hit Enter to terminate!" << endl;
      cin.get();

      return 0;
   }

5.相關鏈接

5.1  介紹函數(shù)指針

• Using Member Function Pointers  一個borland社區(qū)的詳細文章. 原本是為了給產(chǎn)品BC3.1提供支持但實際上它是平臺獨立的并且一直在維護更新.  [文章]
• Classes having Pointers to Members 《C++注解》的第15章作者Frank Brokken.  [教程]
• C++ FAQ-Lite  新聞組news.comp.lang.c++的FAQ. 該鏈接指向的是成員函數(shù)指針那部分.  [FAQ]
• Pointing to Class Members  一個較短但很有用的文章，闡述了怎么使用成員函數(shù)指針.  [教程]
• Declaring Function Pointers and Implementing Callbacks  關于C的函數(shù)指針的比較短小的文章. 里面也描述了函數(shù)標識的調(diào)用規(guī)約.  [教程]
• Notes on Function Pointers   為了闡明通用編程(generic programming)的思想的一篇簡要教程: 分割算法和數(shù)據(jù). 容器類的使用函數(shù)指針的例子, 例如. 調(diào)用用戶指定的函數(shù)為每一個容器元素. [教程]

5.2  回調(diào)和仿函數(shù)

• Callbacks in C++  一個免費的回調(diào)庫和一篇科學且實用的回調(diào)文章，闡述了幾乎所有的回調(diào)方法. 為每一個步驟的描述中的源代碼都完全開放. [站點]
• Callbacks in C++ using Template Functors   Rich Hickey 寫的一篇關于回調(diào)概念和模版仿函數(shù)的用法的詳細的文章. 這個站點已經(jīng)被關閉了，文章中的免費C++回調(diào)庫可以再這里下載.   [文章]
• Callbacks in C++ using Template Functors II  關于使用Rich Hickey的回調(diào)機制的一篇教程. 也解釋了其他的普通方案為什么不可取的原因.  [教程]
• Myelin: How to write Callbacks in C++ and COM  解釋怎么使用純虛類做成回調(diào)的短文章.  [文章]
• Myelin: Implementing delegates in C++   怎么在C++中實現(xiàn)委派 ... [文章]
• Callbacks in C++: The OO Way    [文章]
• C++ Callback Solution   使用模版做成成員函數(shù)的回調(diào). [文章]
• Member Function Pointers and the Fastest Possible C++ Delegates  怎么在C++中實現(xiàn)委派... [文章]
• Callbacks   關于回調(diào)和仿函數(shù)的簡單說明.  [教程]
• Comparison of Callback Mechanisms   討論C++中實現(xiàn)回調(diào)機制的5個可選方法的可用性和性能方面的對比.  [文章]
• libsigc++  用抽象回調(diào)連接一個類的方法，函數(shù)，或函數(shù)對象的一個完全的回調(diào)庫.  [函數(shù)庫]
• Library Boost/Function   Doug Gregor寫得函數(shù)對象包裝器. 該文檔能在 www.boost.org 里下載到 . [函數(shù)庫]
• Library Boost/Functional   Mark Rodgers寫的加強函數(shù)對象適配器. 該文檔能在 www.boost.org 里下載到. [函數(shù)庫]

5.2  其他項

• PC Assembly Tutorial   關于匯編的一篇很好的教程. 這里你能了解到一個函數(shù)調(diào)用是怎么工作的. 另外還有調(diào)用規(guī)約以及匯編和C代碼的之間的交互. [教程]
• The Virtual Function Mechanism  關于使用Microsoft's Visual C++匯編器的虛函數(shù)機制一篇簡要介紹 [文章]