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

 解決方案

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

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

 模板（template）的使用非常方便，模板本身可被實例化為一個對象指針（object pointer）或者一個簡單的類（class）。當作為對象指針使用時，C++有另外一個令人痛苦的限制：operator() 不可以在指針未被解引用的情況下調用，對于這個限制，一個簡便的但卻不怎么優雅的解決方法在一個模板內部增加一個execute方法（method），由這個方法從模板內部來調用operator()。除了這一點不爽之外，實例化SinglarCallBack為一個對象指針將可以使你擁有一個由回調組成的vector，或者任何其他類型的集合，這在事件驅動程序設計中是非常需要的。
 假設以下兩個類已經存在，而且我們想讓methodB作為我們的回調方法，從代碼中我們可以看到當傳遞一個class A類的參數并調用methodB時，methodB會調用A類的output方法，如果你能在stdout上看到"I am class A :D"，就說明回調成功了。
 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;
     }
 };
 有兩種方法可以從一個對象指針上調用一個回調方法，較原始的方法是解引用（dereference）一個對象指針并運行回調方法（即：operator()），第二個選擇是運行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;
 }
 更復雜的例子，一個回調模板可以像下面這樣使用：
 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;
}

下面這個例子比上面的又復雜一些，你可以混合從同一個公共基類（base class）上繼承下來的不同的類到一個容器中，于是你就可以調用位于繼承樹的最底層的類的方法（most derived method）。（譯者注，C++的多態機制）
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）相關的必要代碼沒有被包含進來，在實際的程序設計中，類實例的傳遞應該基于這樣的結構：使用類似智能指針（smart pointer）的包裝類。STL（標準模板庫）提供了兩個極好的選擇：aotu_ptr以及它的后繼：shared_ptr。Andrei Alexandrescu所著的《Modern C++ Design》一書也提供了一個面向策略設計（policy design oriented）的智能指針類。這三種方案中各有自己的優缺點，最終由用戶自己來決定究竟那一種最適合他們的需要。