跟诸如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）的智能指针类。这三种方案中各有自己的优缺点，最终由用户自己来决定究竟那一种最适合他们的需要。