跟諸如Object Pascal和Ada等其它一些語言不同，C++語言并沒有內(nèi)在地提供一種將類的方法作為回調(diào)函數(shù)使用的方案。在C語言中，這種回調(diào)函數(shù)被稱作算子（functor），在事件驅(qū)動類程序中普遍存在。主要問題基于這樣一個事實：某個類的多個實例各自位于內(nèi)存的不同位置。這就需要在回調(diào)的時候不僅需要一個函數(shù)指針，同時也需要一個指針指向某個實例本身（譯者注：否則回調(diào)時便無法知道目前正在操作的是哪個對象，C++類的非靜態(tài)方法包含一個默認(rèn)的“參數(shù)”：this指針，就是起這種作用的）。所以，針對問題的定義，有一個很直觀的解決方法就是使用模板和編譯時的實例化及特化。

 解決方案

 這里的方案只支持一個模板參數(shù)，但如果一些能夠如愿的話，隨著更多的編譯器完全實現(xiàn)C++標(biāo)準(zhǔn)，以后將會支持動態(tài)的模板參數(shù)，比如“…”形式的模板參數(shù)列表（參見《C++ Templates, The Complete Guide》），那時，我們就可以可以實現(xiàn)無需全部預(yù)定義的參數(shù)集合。（文中所有代碼的注釋為譯者加，下同。）

 template < class Class, typename ReturnType, typename Parameter >
 class SingularCallBack
 {
   public:
//指向類成員函數(shù)的指針，用他來實現(xiàn)回調(diào)函數(shù)。
 typedef ReturnType (Class::*Method)(Parameter);
     //構(gòu)造函數(shù)
     SingularCallBack(Class* _class_instance, Method _method)
     {
        class_instance = _class_instance;
       method        = _method;
     };
 //重載函數(shù)調(diào)用運(yùn)算符()
     ReturnType operator()(Parameter parameter)
     {
        return (class_instance->*method)(parameter);
     };
     //與上面的()等價的函數(shù)，引入這個函數(shù)的原因見下文
     ReturnType execute(Parameter parameter)
     {
        return operator()(parameter);
 };
    private:
     Class*  class_instance;
     Method  method;
 };
 模板的使用

 模板（template）的使用非常方便，模板本身可被實例化為一個對象指針（object pointer）或者一個簡單的類（class）。當(dāng)作為對象指針使用時，C++有另外一個令人痛苦的限制：operator() 不可以在指針未被解引用的情況下調(diào)用，對于這個限制，一個簡便的但卻不怎么優(yōu)雅的解決方法在一個模板內(nèi)部增加一個execute方法（method），由這個方法從模板內(nèi)部來調(diào)用operator()。除了這一點(diǎn)不爽之外，實例化SinglarCallBack為一個對象指針將可以使你擁有一個由回調(diào)組成的vector，或者任何其他類型的集合，這在事件驅(qū)動程序設(shè)計中是非常需要的。
 假設(shè)以下兩個類已經(jīng)存在，而且我們想讓methodB作為我們的回調(diào)方法，從代碼中我們可以看到當(dāng)傳遞一個class A類的參數(shù)并調(diào)用methodB時，methodB會調(diào)用A類的output方法，如果你能在stdout上看到"I am class A :D"，就說明回調(diào)成功了。
 class A
 {
    public:
    void output()
     {
        std::cout << "I am class A :D" << std::endl;
     };
 };
 class B
 {
    public:
     bool methodB(A a)
     {
        a.output();
        return true;
     }
 };
 有兩種方法可以從一個對象指針上調(diào)用一個回調(diào)方法，較原始的方法是解引用（dereference）一個對象指針并運(yùn)行回調(diào)方法（即：operator()），第二個選擇是運(yùn)行execute方法。
 //第一種方法：
 A a;
 B b;
 SingularCallBack< B,bool,A >* cb;
 cb = new SingularCallBack< B,bool,A >(&b,&B::methodB);
 if((*cb)(a))
 {
    std::cout << "CallBack Fired Successfully!" << std::endl;
 }
 else
 {
   std::cout << "CallBack Fired Unsuccessfully!" << std::endl;
 }
 //第二種方法：
 A a;
 B b;
 SingularCallBack< B,bool,A >* cb;
 cb = new SingularCallBack< B,bool,A >(&b,&B::methodB);
 if(cb->execute(a))
 {
    std::cout << "CallBack Fired Successfully!" << std::endl;
 }
 else
 {
    std::cout << "CallBack Fired Unsuccessfully!" << std::endl;
 }
 下面的代碼示范了怎樣將一個模板實例化成一個普通的對象并使用之。
 A a;
 B b;
 SingularCallBack< B,bool,A >cb(&b,&B::methodB);
 {
    std::cout << "CallBack Fired Successfully!" << std::endl;
 }
 else
 {
    std::cout << "CallBack Fired Unsuccessfully!" << std::endl;
 }
 更復(fù)雜的例子，一個回調(diào)模板可以像下面這樣使用：
 class AClass
 {
   public:
      AClass(unsigned int _id): id(_id){};
     ~AClass(){};
      bool AMethod(std::string str)
      {
         std::cout << "AClass[" << id << "]: " << str << std::endl;
         return true;
      };
    private:
     unsigned int id;
 };
 typedef SingularCallBack < AClass, bool, std::string > ACallBack;
 int main()
 {
    std::vector < ACallBack > callback_list;
    AClass a1(1);
    AClass a2(2);
    AClass a3(3);
    callback_list.push_back(ACallBack(&a1, &AClass::AMethod));
    callback_list.push_back(ACallBack(&a2, &AClass::AMethod));
    callback_list.push_back(ACallBack(&a3, &AClass::AMethod));
    for (unsigned int i = 0; i < callback_list.size(); i++)
    {
       callback_list[i]("abc");
    }
 
   for (unsigned int i = 0; i < callback_list.size(); i++)
   {
      callback_list[i].execute("abc");
   }
 
   return true;
}

下面這個例子比上面的又復(fù)雜一些，你可以混合從同一個公共基類（base class）上繼承下來的不同的類到一個容器中，于是你就可以調(diào)用位于繼承樹的最底層的類的方法（most derived method）。（譯者注，C++的多態(tài)機(jī)制）
class BaseClass
{
   public:
     virtual ~BaseClass(){};
     virtual bool DerivedMethod(std::string str){ return true; };
};

class AClass : public BaseClass
{
   public:
     AClass(unsigned int _id): id(_id){};
    ~AClass(){};
     bool AMethod(std::string str)
     {
        std::cout << "AClass[" << id << "]: " << str << std::endl;
        return true;
     };

     bool DerivedMethod(std::string str)
     {
        std::cout << "Derived Method AClass[" << id << "]: " << str << std::endl;
        return true;
     };

   private:
    unsigned int id;
};

class BClass : public BaseClass
{
   public:
    BClass(unsigned int _id): id(_id){};
    ~BClass(){};
     bool BMethod(std::string str)
     {
        std::cout << "BClass[" << id << "]: " << str << std::endl;
        return true;
     };

     bool DerivedMethod(std::string str)
     {
        std::cout << "Derived Method BClass[" << id << "]: " << str << std::endl;
        return true;
     };
   private:
    unsigned int id;

};

typedef SingularCallBack < BaseClass, bool, std::string > BaseCallBack;

int main()
{
   std::vector < BaseCallBack > callback_list;

   AClass a(1);
   BClass b(2);

   callback_list.push_back(BaseCallBack(&a, &BaseClass::DerivedMethod));
   callback_list.push_back(BaseCallBack(&b, &BaseClass::DerivedMethod));

   for (unsigned int i = 0; i < callback_list.size(); i++)
   {
      callback_list[i]("abc");
   }

   for (unsigned int i = 0; i < callback_list.size(); i++)
   {
      callback_list[i].execute("abc");
   }

   return true;
}

為簡捷起見，與實例的驗證（instance validation）相關(guān)的必要代碼沒有被包含進(jìn)來，在實際的程序設(shè)計中，類實例的傳遞應(yīng)該基于這樣的結(jié)構(gòu)：使用類似智能指針（smart pointer）的包裝類。STL（標(biāo)準(zhǔn)模板庫）提供了兩個極好的選擇：aotu_ptr以及它的后繼：shared_ptr。Andrei Alexandrescu所著的《Modern C++ Design》一書也提供了一個面向策略設(shè)計（policy design oriented）的智能指針類。這三種方案中各有自己的優(yōu)缺點(diǎn)，最終由用戶自己來決定究竟那一種最適合他們的需要。