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

      当然假设是静态成员函数就好办跟全局函数是类似，到此为止世界还没有变乱，如在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多传个对象进去，好吧，貌似问题攻克了。但是，调用者(如库的提供商)仅仅知道回调函数接口长这样而已，事先完全不知客户的类是怎样定义，最终模板登上场了：

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

所以要支持各种參数，多个參数，还得模板，嗯嗯。努力尚未成功。同志还需革命！

多态回调

     甭管什么名词。总之我们的目的是：产生某个事件时，调用某个待客户实现的行为，调用者什么时候调用确定了。关键是客户依照规定接口实现这个行为，这听起来有点像多态了。是的，有时候被调用者与调用者是继承关系，这就不须要其他理论了，就多态呗。只是多态不一定非得用虚函数来实现，就像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 slotkeyword，不是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将它们连接起来就可以，已经非常组件化了。但是离真正的project应用尚有一段距离，如它不能接收全局函数或静态成员函数或仿函数为回调函数。不能带两个或很多其它的函数參数，最后一步了。