c++ 回调的实现

什么是回调？通常发生在需要两个角色即调用者与实现者的情形上，即我们希望当产生某个事件时，调用实现者定义的某个函数。当然这个概念很大，不是说操作系统的信号量，条件变量什么的，是在语言级别实现，如一个Framework提供商，规定了整个程序的框架，可能产生某事件时它希望调用某个行为，而这个行为的具体定义是由framework客户来完成。

     我们从简单的做起，通过一个个为什么最终来获得一个比较好的回调实现。

C语言中用全局函数实现回调最简单了：

void callback(int a)
{
    cout<<"callback called with para="<<a<<endl;
}

typedef void (*pfunc)(int);
void caller(pfunc p)
{
    (*p)(1);
}

int main(int argc, char* argv[])
{ 
    caller(&callback);
}

      相信不用多解释了吧， 可是到了面向对象的世界里，就不是那么简单了，如果回调函数是成员函数怎么办？

非静态成员函数作回调函数

      当然如果是静态成员函数就好办跟全局函数是类似，到此为止世界还没有变乱，如在VC编程中用AfxBeginThread开启一个线程，就经常将参数AFX_THREADPROC pfnThreadProc定义为一个全局函数或静态成员函数，可是这两个都不方便访问类的非静态成员，之所以郑重其事地写这篇文章，就是以前静态回调用起来非常不爽。

      回调函数是非静态成员函数呢？我们可不能简单地设为这样：

class CCallback
{
public:
    void Func(int a)
    {
        cout<<"member function callback called with para="<<a<<endl;
    }
};
typedef void (CCallback::*pMemberFunc)(int);
void Caller(pMemberFunc p)
{
    (*p)(1);
}

     这样编译就不会通过的，因为非静态的成员函数必须通过对象来访问，好，我们稍稍改进一下：

class CCallback
{
public:
    void Func(int a)
    {
        cout<<"member function callback called with para="<<a<<endl;
    }
};
typedef void (CCallback::*pMemberFunc)(int);
void Caller(CCallback* pObj,pMemberFunc p)
{
    (pObj->*p)(1);
}

int main(int argc, char* argv[])
{ 
    CCallback obj;
    Caller(&obj,&CCallback::Func);
}

      即给Caller多传个对象进去，好吧，貌似问题解决了，可是，调用者(如库的提供商)只知道回调函数接口长这样而已，事先全然不知客户的类是如何定义，终于模板登上场了：

template<typename T>
void Caller(T* pObj,void (T::*p)(int))
{
    (pObj->*p)(1);
}

     其他不变的，把调用者这里换成模板就OK了，当然这个Caller也可以是成员函数，现在用这个方法写个小应用是没什么问题了，但是限制多多，如调用者一次只调用了一个实现，但现实情况往往是产生某个事件时，应该依次调用多个行为，即把挂在这个事件上的所有回调函数通通临幸一遍，还有回调是如此的重要，以至于C#不用库在语言本身层面就实现了它，我们也不可以到此草草了事，而是按照组件化的思维提供一套完善的回调机制，所谓完善，如上个例子中Caller只能接收一个参数为int，返回值为void的成员函数指针，等等，必须是这样的接口吗，想想参数为double行不行，如void (T::*p)(double)这样的函数传给它可以吗，int不是可自动转换为double吗，那这个函数指针也能自动转换吗，就像C#中的协变与逆变一样，不行，C++不允许，当然我们可以强制转换，不过要在十分清楚类型的情况下才能这么做，否则因为不是类型安全的很容易引起程序错误甚至崩溃。所以要支持各种参数，多个参数，还得模板，嗯嗯，努力尚未成功，同志还需革命！

多态回调

     甭管什么名词，总之我们的目的是：产生某个事件时，调用某个待客户实现的行为，调用者什么时候调用确定了，关键是客户按照规定接口实现这个行为，这听起来有点像多态了，是的，有时候被调用者与调用者是继承关系，这就不需要其它理论了，就多态呗，不过多态不一定非得用虚函数来实现，就像MFC一样，考虑到每个类背负一个庞大的虚函数表会带来很大的性能损失，换做用几个结构体和强大的宏而实现消息映射。在wincore.cpp中，CWnd::OnWndMsg源码里,当来了消息，在事先建立的链表中从派生类依次向上查找第一个实现了这个消息的类的AFX_MSGMAP结构体，再取得它的AFX_MSGMAP_ENTRY成员，即真正的消息入口地址，

struct AFX_MSGMAP_ENTRY
{
    UINT nMessage;   // windows message
    UINT nCode;      // control code or WM_NOTIFY code
    UINT nID;        // control ID (or 0 for windows messages)
    UINT nLastID;    // used for entries specifying a range of control id‘s
    UINT nSig;       // signature type (action) or pointer to message #
    AFX_PMSG pfn;    // routine to call (or special value)
};

     就类似于写一个普通的链表结构：struct list_node{list_node* next; int data}，只不过这里的链表的next不能再随便指，要指向基类的节点，根据next指针找到对应的节点后取出数据data成员即可，在这里，data就是AFX_MSGMAP_ENTRY，如上图，AFX_MSGMAP_ENTRY里定义了消息标号即各种附加参数，还有最关键的成员pfn,代表了事先派生类通过宏填充好的回调成员函数地址。但是pfn的类型即AFX_PMSG定义为typedef void (AFX_MSG_CALL CCmdTarget::*AFX_PMSG)(void); 只能代表一种类型，而客户的派生类的为响应消息的回调函数的类型有很多种，在框架中如何保证以正确的形式调用呢？原来客户在填充消息标号和函数地址时，也顺便填充好了函数类型交给nSig成员保存，根据nSig，如前文所说，将pfn强制转换到相应的类型就OK了，不过这成员函数指针转换来转换去，代码非常难看啊可读性不强，于是使用union进行类型转换：

//afximpl.h
union MessageMapFunctions
{
    AFX_PMSG pfn;   // generic member function pointer

    // specific type safe variants for WM_COMMAND and WM_NOTIFY messages
    void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND)();
    BOOL (AFX_MSG_CALL CCmdTarget::*pfn_bCOMMAND)();
    void (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND_RANGE)(UINT);
    BOOL (AFX_MSG_CALL CCmdTarget::*pfn_COMMAND_EX)(UINT);
...
}

//wincore.cpp  CWnd::OnWndMsg
union MessageMapFunctions mmf;
mmf.pfn = lpEntry->pfn;
nSig = lpEntry->nSig;
switch (nSig)
    {
    default:
        ASSERT(FALSE);
        break;

    case AfxSig_bD:
        lResult = (this->*mmf.pfn_bD)(CDC::FromHandle((HDC)wParam));
        break;

    case AfxSig_bb:     // AfxSig_bb, AfxSig_bw, AfxSig_bh
        lResult = (this->*mmf.pfn_bb)((BOOL)wParam);
        break;

    case AfxSig_bWww:   // really AfxSig_bWiw
        lResult = (this->*mmf.pfn_bWww)(CWnd::FromHandle((HWND)wParam),
            (short)LOWORD(lParam), HIWORD(lParam));
        break;
...
}

     当然这里只是一个小插曲而已，它只是MFC为满足于自己应用设计这么一套机制，派生类的回调函数类型是有限的，再则要求与框架类是继承关系，如果没有继承关系怎么办，例如当产生串口或者网口收到数据的事件时，需要更新UI界面，UI界面与串口类可是没有丝毫继承关系的，呃...铁人王进喜说：有条件要上，没条件创造条件也要上，我们大不了专门定义一个回调抽象类，让UI界面继承自它，实现类里的回调函数，然后串口类通过抽象类型对象指针就可以多态地调用到UI的真正回调实现。COM/ATL的回调，Java的回调就是这么干。不过在C++中，情形有些不一样，这样实现很勉强，它需要多重继承，仍然不能直接实现同时调用多个行为，耦合性高，每个回调都需要单独定义一个类(只要接口不一样)，效率也不够高，我们想直接调用到绑定好的回调，基于这些缺点，还得寻找更好的方法。

信号与槽(Signal/Slots)

      说了这么多，终于来到正题了，在C++中，信号与槽才是回调的完美解决方案，其实本质上是一个观察者模式，包括其它的叫法：delegate,notifier/receiver,observer,C#中的delegate也是一个观察者的实现。Qt中提供了信号与槽的整套机制，任何对象的槽可以绑定到另一个对象的信号上，一个信号可以拥有多个槽，经典的图例如下：

     可是qt中的实现用了signal slot关键字，不是C++标准的啊，其它编译器不能随便编译(好像先经过qmake生成标准的代码就可以了)，直接上源码不妥得搞清楚为什么，一切从最简单的入手，我们先来用标准C++实现一个简易的signal/slots，如何实现呢，说白了，就是想方设法把回调函数信息保存起来，必要时利用它就OK了，回调函数信息就两个，类对象指针与成员函数地址，我们将这对信息存储到名叫slot的类中，而在signal类中，维护多个slot即可，仍然用带一个int参数，返回值为void的函数接口：

#include <vector>
#include <iostream>
using namespace std;

template<typename T, typename T1>
class slot
{
public:
    slot(T* pObj,void (T::*pMemberFunc)(T1))
    {
        m_pObj=pObj;
        m_pMemberFunc=pMemberFunc;
    }
    void Execute(T1 para)
    {
        (m_pObj->*m_pMemberFunc)(para);
    }
private:
    T* m_pObj;
    void (T::*m_pMemberFunc)(T1);
};

template<typename T, typename T1>
class signal
{
public:
    void bind(T* pObj,void (T::*pMemberFunc)(T1 para))
    {
        m_slots.push_back(new slot<T,T1>(pObj,pMemberFunc));
    }
    ~signal()
    {
        vector<slot<T,T1>* >::iterator ite=m_slots.begin();
        for (;ite!=m_slots.end();ite++)
        {
            delete *ite;
        }
    }
    void operator()(T1 para)
    {
        vector<slot<T,T1>* >::iterator ite=m_slots.begin();
        for (;ite!=m_slots.end();ite++)
        {
            (*ite)->Execute(para);
        }
    }
    
private:
    vector<slot<T,T1>* > m_slots;
};

class receiver
{
public:
    void callback1(int a)
    {
        cout<<"receiver1: "<<a<<endl;
    }
    void callback2(int a)
    {
        cout<<"receiver2: "<<a<<endl;
    }
};


class sender
{
public:
    sender(): m_value(0)  {}
    int get_value()
    {
        return m_value;
    }
    void set_value(int new_value)
    {
        if (new_value!=m_value)
        {
            m_value=new_value;
            m_sig(new_value);
        }
    }
    signal<receiver,int> m_sig;
private:
    int m_value;
};



int main(int argc,char** arg)
{
    receiver r;
    sender s;
    s.m_sig.bind(&r,&receiver::callback1);
    s.m_sig.bind(&r,&receiver::callback2);
    s.set_value(1);
    return 0;
}

     程序在VC6下顺利通过，这个版本相比前面所说的继承手法耦合性低了，被调用者receiver与规定函数接口的slot类没有任何关系，但仔细以观察这个程序在概念上是有问题的，signal类有两个模板参数，一个是类的类型，一个是函数参数类型，如果把这个signal/slots组件提供出去，使用者如上面的sender类不免会有个疑虑：在实例化signal类型时，必须提供这两个模板参数，可是调用方事先哪就一定知道接收方(receiver)的类型呢，而且从概念上讲事件发送方与接收方只需遵循一个共同的函数接口就可以了，与类没什么关系，上个程序要求在实例化时就得填充receiver的类型，也就决定了它与receiver只能一对一，而不能一对多，于是作此改进：将signal的参数T去掉，将T类型的推导延迟到绑定(bind)时，signal没有参数T，signal的成员slot也就不能有，那slot的成员也就不能有，可是，参数T总得找个地方落脚啊，怎么办？有个窍门：让slot包含slotbase成员，slotbase没有参数T的，但slotbase只定义接口，真正的实现放到slotimpl中，slotimpl就可以挂上参数T了，boost中any、shared_ptr就是用此手法，改进后全部代码如下：

#include <vector>
#include <iostream>
using namespace std;

template<typename T1>
class slotbase
{
public:
    virtual void Execute(T1 para)=0;
};

template<typename T,typename T1>
class slotimpl : public slotbase<T1>
{
public:
    slotimpl(T* pObj,void (T::*pMemberFunc)(T1))
    {
        m_pObj=pObj;
        m_pMemberFunc=pMemberFunc;
    }
    virtual void Execute(T1 para)
    {
        (m_pObj->*m_pMemberFunc)(para);
    }
private:
    T* m_pObj;
    void (T::*m_pMemberFunc)(T1);
};

template<typename T1>
class slot 
{
public:
    template<typename T>
        slot(T* pObj,void (T::*pMemberFunc)(T1)) 
    {
        m_pSlotbase=new slotimpl<T,T1>(pObj,pMemberFunc);
    }
    ~slot()
    {
        delete m_pSlotbase;
    }
    void Execute(T1 para)
    {
        m_pSlotbase->Execute(para);
    }
private:
    slotbase<T1>* m_pSlotbase;
};

template<typename T1>
class signal
{
public:
    template<typename T>
    void bind(T* pObj,void (T::*pMemberFunc)(T1 para))
    {
        m_slots.push_back(new slot<T1>(pObj,pMemberFunc));
    }
    ~signal()
    {
        vector<slot<T1>* >::iterator ite=m_slots.begin();
        for (;ite!=m_slots.end();ite++)
        {
            delete *ite;
        }
    }
    void operator()(T1 para)
    {
        vector<slot<T1>* >::iterator ite=m_slots.begin();
        for (;ite!=m_slots.end();ite++)
        {
            (*ite)->Execute(para);
        }
    }
    
private:
    vector<slot<T1>* > m_slots;
};

#define CONNECT(sender,signal,receiver,slot)  sender.signal.bind(receiver,slot)

class receiver
{
public:
    void callback1(int a)
    {
        cout<<"receiver1: "<<a<<endl;
    }
};
class receiver2
{
public:
    void callback2(int a)
    {
        cout<<"receiver2: "<<a<<endl;
    }
};

class sender
{
public:
    sender(): m_value(0)  {}
    int get_value()
    {
        return m_value;
    }
    void set_value(int new_value)
    {
        if (new_value!=m_value)
        {
            m_value=new_value;
            m_valueChanged(new_value);
        }
    }
    signal<int> m_valueChanged;
private:
    int m_value;
    
};

int main(int argc,char** arg)
{
    receiver r;
    receiver2 r2;
    sender s;
    CONNECT(s,m_valueChanged,&r,&receiver::callback1);
    CONNECT(s,m_valueChanged,&r2,&receiver2::callback2);
    s.set_value(1);
    return 0;
}

     这个版本就比较像样了，一个signal可与多个slots连接，增加了类似QT的connect，用宏实现#define CONNECT(sender,signal,receiver,slot) sender.signal.bind(receiver,slot)，这样使用者就非常方便，而且现在已完全解耦，sender只管定义自己的signal，在恰当时机用仿函数形式调用即可，而receiver只管实现callback，互不影响，可独立工作，如果需要再通过CONNECT将它们连接起来即可，已经很组件化了，可是离真正的工程应用尚有一段距离，如它不能接收全局函数或静态成员函数或仿函数为回调函数，不能带两个或更多的函数参数，最后一步了。

c++ 回调的实现,古老的榕树,5-wow.com